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

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

@@ -2,12 +2,12 @@ import network from "@ledgerhq/live-network/network";
 import { DEFAULT_SWAP_TIMEOUT_MS } from "../../const/timeout";
 import { flattenV5CurrenciesToAndFrom } from "../../utils/flattenV5CurrenciesToAndFrom";
 import { fetchCurrencyFromMock } from "./__mocks__/fetchCurrencyFrom.mocks";
-import { getSwapAPIBaseURL } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 import { getEnv } from "@ledgerhq/live-env";
 
 type Props = {
-  providers: Array<string>;
   currencyTo?: string;
+  providers: string[];
   additionalCoinsFlag?: boolean;
 };
 
@@ -19,16 +19,18 @@ export type ResponseData = {
 };
 
 export async function fetchCurrencyFrom({
-  providers,
   currencyTo,
+  providers,
   additionalCoinsFlag = false,
 }: Props) {
   if (getEnv("MOCK") || getEnv("PLAYWRIGHT_RUN"))
     return flattenV5CurrenciesToAndFrom(fetchCurrencyFromMock);
 
+  const headers = getSwapUserIP();
   const url = new URL(`${getSwapAPIBaseURL()}/currencies/from`);
   url.searchParams.append("providers-whitelist", providers.join(","));
   url.searchParams.append("additional-coins-flag", additionalCoinsFlag.toString());
+
   if (currencyTo) {
     url.searchParams.append("currency-to", currencyTo);
   }
@@ -38,6 +40,7 @@ export async function fetchCurrencyFrom({
       method: "GET",
       url: url.toString(),
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
+      ...(headers !== undefined ? { headers } : {}),
     });
     return flattenV5CurrenciesToAndFrom(data);
   } catch (e) {

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

@@ -5,7 +5,7 @@ import { DEFAULT_SWAP_TIMEOUT_MS } from "../../const/timeout";
 import axios from "axios";
 import { LedgerAPI4xx } from "@ledgerhq/errors";
 import { flattenV5CurrenciesToAndFrom } from "../../utils/flattenV5CurrenciesToAndFrom";
-import { getSwapAPIBaseURL } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 
 type Props = {
   currencyFromId?: string;
@@ -34,12 +34,14 @@ export async function fetchCurrencyTo({
   url.searchParams.append("providers-whitelist", providers.join(","));
   url.searchParams.append("additional-coins-flag", additionalCoinsFlag.toString());
   url.searchParams.append("currency-from", currencyFromId!);
+  const headers = getSwapUserIP();
 
   try {
     const { data } = await network<ResponseData>({
       method: "GET",
       url: url.toString(),
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
+      ...(headers !== undefined ? { headers } : {}),
     });
     return flattenV5CurrenciesToAndFrom(data);
   } catch (e: unknown) {

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

@@ -8,7 +8,7 @@ import { SwapGenericAPIError } from "../../../../errors";
 import { enrichRatesResponse } from "../../utils/enrichRatesResponse";
 import { isIntegrationTestEnv } from "../../utils/isIntegrationTestEnv";
 import { fetchRatesMock } from "./__mocks__/fetchRates.mocks";
-import { getSwapAPIBaseURL } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 
 type Props = {
   providers: Array<string>;
@@ -94,15 +94,16 @@ export async function fetchRates({
     from: currencyFrom,
     to: toCurrencyId,
     amountFrom: fromCurrencyAmount, // not sure why amountFrom thinks it can be undefined here
-    providers,
+    providers: providers,
   };
-
+  const headers = getSwapUserIP();
   try {
     const { data } = await network<ExchangeRateResponseRaw[]>({
       method: "POST",
       url: url.toString(),
       timeout: DEFAULT_SWAP_TIMEOUT_MS,
       data: requestBody,
+      ...(headers !== undefined ? { headers } : {}),
     });
     const filteredData = data.filter(
       response => ![300, 304, 306, 308].includes((response as ExchangeRateErrorDefault)?.errorCode),

package/src/exchange/swap/completeExchange.ts

@@ -23,6 +23,8 @@ import type { CompleteExchangeInputSwap, CompleteExchangeRequestEvent } from "..
 import { getSwapProvider } from "../providers";
 import { convertToAppExchangePartnerKey } from "../providers";
 import { CompleteExchangeStep, convertTransportError } from "../error";
+import { getDefaultAccountName } from "@ledgerhq/live-wallet/accountName";
+import { TronSendTrc20ToNewAccountForbidden } from "../../families/tron/errors";
 
 const withDevicePromise = (deviceId, fn) =>
   firstValueFrom(withDevice(deviceId)(transport => from(fn(transport))));
@@ -46,7 +48,7 @@ const completeExchange = (
 
     const confirmExchange = async () => {
       await withDevicePromise(deviceId, async transport => {
-        const providerConfig = getSwapProvider(provider);
+        const providerConfig = await getSwapProvider(provider);
         if (providerConfig.type !== "CEX") {
           throw new Error(`Unsupported provider type ${providerConfig.type}`);
         }
@@ -73,7 +75,10 @@ const completeExchange = (
         );
         if (unsubscribed) return;
 
-        const errorsKeys = Object.keys(errors);
+        const errorsKeys = Object.keys(errors).filter(item =>
+          [TronSendTrc20ToNewAccountForbidden.prototype.name].includes(item),
+        );
+
         if (errorsKeys.length > 0) throw errors[errorsKeys[0]]; // throw the first error
 
         currentStep = "SET_PARTNER_KEY";
@@ -123,7 +128,7 @@ const completeExchange = (
             throw new WrongDeviceForAccountPayout(
               getExchangeErrorMessage(e.statusCode, currentStep),
               {
-                accountName: payoutAccount.name,
+                accountName: getDefaultAccountName(payoutAccount),
               },
             );
           }
@@ -165,7 +170,7 @@ const completeExchange = (
             throw new WrongDeviceForAccountRefund(
               getExchangeErrorMessage(e.statusCode, currentStep),
               {
-                accountName: refundAccount.name,
+                accountName: getDefaultAccountName(refundAccount),
               },
             );
           }

package/src/exchange/swap/csvExport.ts

@@ -1,6 +1,7 @@
 import { formatCurrencyUnit } from "../../currencies";
 import { getAccountCurrency, getMainAccount } from "../../account";
 import type { SwapHistorySection, MappedSwapOperation } from "./types";
+import { getDefaultAccountName } from "@ledgerhq/live-wallet/accountName";
 type Field = {
   title: string;
   cell: (arg0: MappedSwapOperation) => string;
@@ -50,7 +51,7 @@ const fields: Field[] = [
   {
     title: "From account",
     cell: ({ fromAccount, fromParentAccount }) =>
-      getMainAccount(fromAccount, fromParentAccount).name,
+      getDefaultAccountName(getMainAccount(fromAccount, fromParentAccount)),
   },
   {
     title: "From account address",
@@ -61,7 +62,8 @@ const fields: Field[] = [
   },
   {
     title: "To account",
-    cell: ({ toAccount, toParentAccount }) => getMainAccount(toAccount, toParentAccount).name,
+    cell: ({ toAccount, toParentAccount }) =>
+      getDefaultAccountName(getMainAccount(toAccount, toParentAccount)),
   },
   {
     title: "To account address",

package/src/exchange/swap/getExchangeRates.ts

@@ -1,18 +1,18 @@
 import network from "@ledgerhq/live-network/network";
 import type { Unit } from "@ledgerhq/types-cryptoassets";
 import { BigNumber } from "bignumber.js";
-import { getAccountCurrency, getAccountUnit } from "../../account";
+import { getAccountCurrency } from "../../account";
 import { formatCurrencyUnit } from "../../currencies";
 import {
   SwapExchangeRateAmountTooHigh,
   SwapExchangeRateAmountTooLow,
   SwapExchangeRateAmountTooLowOrTooHigh,
 } from "../../errors";
-import { getSwapAPIBaseURL, getSwapAPIError } from "./";
+import { getSwapAPIBaseURL, getSwapAPIError, getSwapUserIP } from "./";
 import { mockGetExchangeRates } from "./mock";
 import type { CustomMinOrMaxError, GetExchangeRates } from "./types";
 import { isIntegrationTestEnv } from "./utils/isIntegrationTestEnv";
-import { getSwapProvider } from "../providers";
+import { getSwapProvider } from "../providers/swap";
 
 const getExchangeRates: GetExchangeRates = async ({
   exchange,
@@ -25,9 +25,10 @@ const getExchangeRates: GetExchangeRates = async ({
   if (isIntegrationTestEnv()) return mockGetExchangeRates(exchange, transaction, currencyTo);
 
   const from = getAccountCurrency(exchange.fromAccount).id;
-  const unitFrom = getAccountUnit(exchange.fromAccount);
+  const unitFrom = getAccountCurrency(exchange.fromAccount).units[0];
   const to = (currencyTo ?? getAccountCurrency(exchange.toAccount)).id;
-  const unitTo = (currencyTo && currencyTo.units[0]) ?? getAccountUnit(exchange.toAccount);
+  const unitTo =
+    (currencyTo && currencyTo.units[0]) ?? getAccountCurrency(exchange.toAccount).units[0];
   const amountFrom = transaction.amount;
   const tenPowMagnitude = new BigNumber(10).pow(unitFrom.magnitude);
   const apiAmount = new BigNumber(amountFrom).div(tenPowMagnitude);
@@ -43,15 +44,17 @@ const getExchangeRates: GetExchangeRates = async ({
     providers: providerList,
   };
 
+  const headers = getSwapUserIP();
   const res = await network({
     method: "POST",
     url: `${getSwapAPIBaseURL()}/rate`,
     ...(timeout ? { timeout } : {}),
     ...(timeoutErrorMessage ? { timeoutErrorMessage } : {}),
     data: request,
+    ...(headers !== undefined ? headers : {}),
   });
 
-  const rates = res.data.map(responseData => {
+  const rates = res.data.map(async responseData => {
     const {
       rate: maybeRate,
       payoutNetworkFees: maybePayoutNetworkFees,
@@ -65,7 +68,7 @@ const getExchangeRates: GetExchangeRates = async ({
       expirationTime,
     } = responseData;
 
-    const error = inferError(apiAmount, unitFrom, responseData);
+    const error = await inferError(apiAmount, unitFrom, responseData);
     if (error) {
       return {
         provider,
@@ -122,7 +125,7 @@ const getExchangeRates: GetExchangeRates = async ({
   return rates;
 };
 
-const inferError = (
+const inferError = async (
   apiAmount: BigNumber,
   unitFrom: Unit,
   responseData: {
@@ -134,11 +137,11 @@ const inferError = (
     status?: string;
     provider: string;
   },
-): Error | CustomMinOrMaxError | undefined => {
+): Promise<Error | CustomMinOrMaxError | undefined> => {
   const tenPowMagnitude = new BigNumber(10).pow(unitFrom.magnitude);
   const { amountTo, minAmountFrom, maxAmountFrom, errorCode, errorMessage, provider, status } =
     responseData;
-  const isDex = getSwapProvider(provider).type === "DEX";
+  const isDex = (await getSwapProvider(provider)).type === "DEX";
 
   // DEX quotes are out of limits error. We do not know if it is a low or high limit, neither the amount.
   if ((!minAmountFrom || !maxAmountFrom) && status === "error" && errorCode !== 300 && isDex) {

package/src/exchange/swap/getStatus.ts

@@ -2,15 +2,17 @@ import network from "@ledgerhq/live-network/network";
 import { mockGetStatus } from "./mock";
 import type { GetMultipleStatus } from "./types";
 import { isIntegrationTestEnv } from "./utils/isIntegrationTestEnv";
-import { getSwapAPIBaseURL } from ".";
+import { getSwapAPIBaseURL, getSwapUserIP } from ".";
 
 export const getMultipleStatus: GetMultipleStatus = async statusList => {
   if (isIntegrationTestEnv()) return mockGetStatus(statusList);
 
+  const headers = getSwapUserIP();
   const res = await network({
     method: "POST",
     url: `${getSwapAPIBaseURL()}/swap/status`,
     data: statusList,
+    ...(headers !== undefined ? { headers } : {}),
   });
   return res.data;
 };

package/src/exchange/swap/getUpdateAccountWithUpdaterParams.ts

@@ -2,8 +2,7 @@ import { BigNumber } from "bignumber.js";
 import { Account, Operation } from "@ledgerhq/types-live";
 import addToSwapHistory from "./addToSwapHistory";
 import { ExchangeSwap, ExchangeRate } from "./types";
-import { addPendingOperation } from "../../account/index";
-import { getMainAccount } from "../../account/helpers";
+import { addPendingOperation, getMainAccount } from "../../account/index";
 import { Transaction } from "../../generated/types";
 
 export const getUpdateAccountWithUpdaterParams = ({

package/src/exchange/swap/hooks/useSwapTransaction.ts

@@ -1,3 +1,5 @@
+import { getAccountCurrency, getFeesUnit } from "@ledgerhq/coin-framework/account/index";
+import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
 import {
   AmountRequired,
   FeeNotLoaded,
@@ -5,22 +7,20 @@ import {
   NotEnoughGas,
   NotEnoughGasSwap,
 } from "@ledgerhq/errors";
+import { Account } from "@ledgerhq/types-live";
 import { useMemo } from "react";
+import useBridgeTransaction, { Result } from "../../../bridge/useBridgeTransaction";
+import { Transaction } from "../../../generated/types";
 import {
-  SwapSelectorStateType,
+  ExchangeRate,
   OnNoRatesCallback,
+  SwapSelectorStateType,
   SwapTransactionType,
-  ExchangeRate,
 } from "../types";
-import useBridgeTransaction, { Result } from "../../../bridge/useBridgeTransaction";
 import { useFromState } from "./useFromState";
-import { useToState } from "./useToState";
 import { useReverseAccounts } from "./useReverseAccounts";
-import { Account } from "@ledgerhq/types-live";
+import { useToState } from "./useToState";
 import { useUpdateMaxAmount } from "./useUpdateMaxAmount";
-import { Transaction } from "../../../generated/types";
-import { getAccountCurrency, getFeesUnit } from "@ledgerhq/coin-framework/account/index";
-import { formatCurrencyUnit } from "@ledgerhq/coin-framework/currencies/index";
 import { useProviderRates } from "./v5/useProviderRates";
 
 export const selectorStateDefaultValues = {
@@ -98,6 +98,7 @@ type UseSwapTransactionProps = {
   excludeFixedRates?: boolean;
   refreshRate?: number;
   allowRefresh?: boolean;
+  isEnabled?: boolean;
 };
 
 export const useSwapTransaction = ({
@@ -110,7 +111,8 @@ export const useSwapTransaction = ({
   excludeFixedRates,
   refreshRate,
   allowRefresh,
-}: UseSwapTransactionProps = {}): SwapTransactionType => {
+  isEnabled,
+}: UseSwapTransactionProps): SwapTransactionType => {
   const bridgeTransaction = useBridgeTransaction(() => ({
     account: defaultAccount,
     parentAccount: defaultParentAccount,
@@ -165,6 +167,7 @@ export const useSwapTransaction = ({
     setExchangeRate,
     countdown: refreshRate,
     allowRefresh,
+    isEnabled,
   });
 
   return {

package/src/exchange/swap/hooks/useUpdateMaxAmount.ts

@@ -43,6 +43,10 @@ export const useUpdateMaxAmount = ({
           let additionalFees;
           if (tx.family === "evm" && next) {
             additionalFees = new BigNumber(5000000000000000); // 0,005 ETH/BNB/MATIC
+          } else if (tx.family === "tron" && next) {
+            // https://github.com/tronprotocol/documentation/blob/master/TRX/Tron-overview.md
+            // 1 TRX=1,000,000 sun.
+            additionalFees = new BigNumber(1).multipliedBy(1_000_000); // 1 TRX
           }
           return {
             ...tx,

package/src/exchange/swap/hooks/v5/useFetchCurrencyAll.ts

@@ -1,18 +1,21 @@
-import { getAvailableProviders } from "../..";
 import { useFeature } from "../../../../featureFlags";
 import { useAPI } from "../../../../hooks/useAPI";
 import { fetchCurrencyAll } from "../../api/v5";
+import { useFilteredProviders } from "./useFilteredProviders";
 
 export function useFetchCurrencyAll() {
   const fetchAdditionalCoins = useFeature("fetchAdditionalCoins");
+  const { providers, loading, error } = useFilteredProviders();
+
   const { data, ...rest } = useAPI({
     queryFn: fetchCurrencyAll,
     queryProps: {
-      providers: getAvailableProviders(),
       additionalCoinsFlag: fetchAdditionalCoins?.enabled,
+      providers,
     },
     // assume the all currency list for the given props won't change during a users session.
     staleTimeout: Infinity,
+    enabled: !loading && !error,
   });
   return {
     ...rest,

package/src/exchange/swap/hooks/v5/useFetchCurrencyFrom.ts

@@ -1,7 +1,7 @@
-import { getAvailableProviders } from "../..";
 import { useFeature } from "../../../../featureFlags";
 import { useAPI } from "../../../../hooks/useAPI";
 import { fetchCurrencyFrom } from "../../api/v5/fetchCurrencyFrom";
+import { useFilteredProviders } from "./useFilteredProviders";
 
 type Props = {
   currencyTo?: string;
@@ -11,15 +11,17 @@ type Props = {
 
 export function useFetchCurrencyFrom({ currencyTo, enabled }: Props = {}) {
   const fetchAdditionalCoins = useFeature("fetchAdditionalCoins");
+  const { providers, loading, error } = useFilteredProviders();
+
   return useAPI({
     queryFn: fetchCurrencyFrom,
     queryProps: {
-      providers: getAvailableProviders(),
       currencyTo,
       additionalCoinsFlag: fetchAdditionalCoins?.enabled,
+      providers,
     },
     // assume a currency list for the given props won't change during a users session.
     staleTimeout: Infinity,
-    enabled,
+    enabled: enabled && !loading && !error,
   });
 }

package/src/exchange/swap/hooks/v5/useFetchCurrencyTo.ts

@@ -2,9 +2,9 @@ import { AccountLike } from "@ledgerhq/types-live";
 import { getAccountCurrency } from "@ledgerhq/coin-framework/account/helpers";
 
 import { fetchCurrencyTo } from "../../api/v5";
-import { getAvailableProviders } from "../..";
 import { useAPI } from "../../../../hooks/useAPI";
 import { useFeature } from "../../../../featureFlags";
+import { useFilteredProviders } from "./useFilteredProviders";
 
 type Props = {
   fromCurrencyAccount: AccountLike | undefined;
@@ -13,18 +13,20 @@ type Props = {
 
 export function useFetchCurrencyTo({ fromCurrencyAccount }: Props) {
   const fetchAdditionalCoins = useFeature("fetchAdditionalCoins");
+  const { providers, loading, error } = useFilteredProviders();
+
   const currencyFromId = fromCurrencyAccount
     ? getAccountCurrency(fromCurrencyAccount).id
     : undefined;
+
   return useAPI({
     queryFn: fetchCurrencyTo,
     queryProps: {
-      providers: getAvailableProviders(),
       currencyFromId,
+      providers,
       additionalCoinsFlag: fetchAdditionalCoins?.enabled,
     },
-    // assume a currency list for the given props won't change during a users session.
     staleTimeout: Infinity,
-    enabled: !!currencyFromId,
+    enabled: !!currencyFromId && !loading && !error,
   });
 }

package/src/exchange/swap/hooks/v5/useFetchRates.ts

@@ -1,18 +1,18 @@
-import { getAvailableProviders } from "../..";
-import { AccountLike } from "@ledgerhq/types-live";
-import { getAccountCurrency, getAccountUnit } from "@ledgerhq/coin-framework/account/helpers";
+import { getAccountCurrency } from "@ledgerhq/coin-framework/account/helpers";
 import { CryptoOrTokenCurrency } from "@ledgerhq/types-cryptoassets";
+import { AccountLike } from "@ledgerhq/types-live";
 import BigNumber from "bignumber.js";
 import { fetchRates } from "../../api/v5/fetchRates";
 import { useAPI } from "../../../../hooks/useAPI";
 import { ExchangeRate } from "../../types";
-import { useFeature } from "../../../../featureFlags";
+import { useFilteredProviders } from "./useFilteredProviders";
 
 type Props = {
   fromCurrencyAccount: AccountLike | undefined;
   toCurrency: CryptoOrTokenCurrency | undefined;
   fromCurrencyAmount: BigNumber;
   onSuccess?(data: ExchangeRate[]): void;
+  isEnabled?: boolean;
 };
 
 export function useFetchRates({
@@ -20,23 +20,22 @@ export function useFetchRates({
   toCurrency,
   fromCurrencyAmount,
   onSuccess,
+  isEnabled = true,
 }: Props) {
   const currencyFrom = fromCurrencyAccount ? getAccountCurrency(fromCurrencyAccount).id : undefined;
-  const unitFrom = fromCurrencyAccount ? getAccountUnit(fromCurrencyAccount) : undefined;
+  const unitFrom = fromCurrencyAccount
+    ? getAccountCurrency(fromCurrencyAccount).units[0]
+    : undefined;
   const unitTo = toCurrency?.units[0];
-  const moonpayFF = useFeature("ptxSwapMoonpayProvider");
   const formattedCurrencyAmount =
     (unitFrom && `${fromCurrencyAmount.shiftedBy(-unitFrom.magnitude)}`) ?? "0";
-  const providers = getAvailableProviders();
+  const { providers, loading, error } = useFilteredProviders();
 
-  if (!moonpayFF?.enabled) {
-    providers.splice(providers.indexOf("moonpay"), 1);
-  }
   const toCurrencyId = toCurrency?.id;
   return useAPI({
     queryFn: fetchRates,
     queryProps: {
-      providers: providers,
+      providers,
       unitTo: unitTo!,
       unitFrom: unitFrom!,
       currencyFrom,
@@ -44,7 +43,15 @@ export function useFetchRates({
       fromCurrencyAmount: formattedCurrencyAmount,
     },
     staleTimeout: 20000,
-    enabled: !!toCurrencyId && !!currencyFrom && fromCurrencyAmount.gt(0) && !!unitFrom && !!unitTo,
+    enabled:
+      !!toCurrencyId &&
+      !!currencyFrom &&
+      fromCurrencyAmount.gt(0) &&
+      !!unitFrom &&
+      !!unitTo &&
+      !loading &&
+      isEnabled &&
+      !error,
     onSuccess,
   });
 }

package/src/exchange/swap/hooks/v5/useFilteredProviders.ts

@@ -0,0 +1,42 @@
+import { useState, useEffect, useCallback } from "react";
+import { useFeature } from "../../../../featureFlags";
+import { fetchAndMergeProviderData } from "../../../providers/swap";
+
+export const useFilteredProviders = () => {
+  const [providers, setProviders] = useState<string[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<unknown>(null);
+
+  const ptxSwapMoonpayProviderFlag = useFeature("ptxSwapMoonpayProvider");
+  const ptxSwapExodusProviderFlag = useFeature("ptxSwapExodusProvider");
+  const ptxSwapThorswapProviderFlag = useFeature("ptxSwapThorswapProvider");
+
+  const fetchProviders = useCallback(async () => {
+    try {
+      const data = await fetchAndMergeProviderData();
+
+      let filteredProviders = Object.keys(data);
+      if (!ptxSwapMoonpayProviderFlag?.enabled) {
+        filteredProviders = filteredProviders.filter(provider => provider !== "moonpay");
+      }
+      if (!ptxSwapExodusProviderFlag?.enabled) {
+        filteredProviders = filteredProviders.filter(provider => provider !== "exodus");
+      }
+      if (!ptxSwapThorswapProviderFlag?.enabled) {
+        filteredProviders = filteredProviders.filter(provider => provider !== "thorswap");
+      }
+
+      setProviders(filteredProviders);
+    } catch (error) {
+      setError(error);
+    } finally {
+      setLoading(false);
+    }
+  }, [ptxSwapMoonpayProviderFlag, ptxSwapExodusProviderFlag, ptxSwapThorswapProviderFlag]);
+
+  useEffect(() => {
+    fetchProviders();
+  }, [fetchProviders]);
+
+  return { providers, loading, error };
+};

package/src/exchange/swap/hooks/v5/useProviderRates.ts

@@ -2,8 +2,7 @@ import BigNumber from "bignumber.js";
 import { OnNoRatesCallback, RatesReducerState, SwapSelectorStateType } from "../../types";
 import { useFetchRates } from "./useFetchRates";
 import { SetExchangeRateCallback } from "../useSwapTransaction";
-import { useFeature } from "../../../../featureFlags";
-import { useCallback, useEffect } from "react";
+import { useEffect } from "react";
 import { useCountdown } from "usehooks-ts";
 import { DEFAULT_SWAP_RATES_INTERVAL_MS } from "../../const/timeout";
 
@@ -14,6 +13,7 @@ type Props = {
   setExchangeRate?: SetExchangeRateCallback | null | undefined;
   countdown?: number;
   allowRefresh?: boolean;
+  isEnabled?: boolean;
 };
 
 export type UseProviderRatesResponse = {
@@ -29,20 +29,13 @@ export function useProviderRates({
   onNoRates,
   setExchangeRate,
   allowRefresh = true,
+  isEnabled = true,
   ...props
 }: Props): UseProviderRatesResponse {
   const [countdown, { startCountdown, resetCountdown, stopCountdown }] = useCountdown({
     countStart: props.countdown ?? DEFAULT_SWAP_RATES_INTERVAL_MS / 1000,
     countStop: 0,
   });
-  const ptxSwapMoonpayProviderFlag = useFeature("ptxSwapMoonpayProvider");
-  const filterMoonpay = useCallback(
-    rates => {
-      if (!rates || ptxSwapMoonpayProviderFlag?.enabled) return rates;
-      return rates.filter(r => r.provider !== "moonpay");
-    },
-    [ptxSwapMoonpayProviderFlag?.enabled],
-  );
 
   const { data, isLoading, error, refetch } = useFetchRates({
     fromCurrencyAccount: fromState.account,
@@ -50,15 +43,15 @@ export function useProviderRates({
     fromCurrencyAmount: fromState.amount ?? BigNumber(0),
     onSuccess(data) {
       resetCountdown();
-      const rates = filterMoonpay(data);
-      if (rates.length === 0) {
+      if (data.length === 0) {
         stopCountdown();
         onNoRates?.({ fromState, toState });
       } else {
         startCountdown();
-        setExchangeRate?.(rates[0]);
+        setExchangeRate?.(data[0]);
       }
     },
+    isEnabled,
   });
 
   useEffect(() => {
@@ -112,7 +105,7 @@ export function useProviderRates({
     return {
       rates: {
         status: "success",
-        value: filterMoonpay(data),
+        value: data,
         error: undefined,
       },
       refetchRates: refetch,

package/src/exchange/swap/index.ts

@@ -19,7 +19,7 @@ import getCompleteSwapHistory from "./getCompleteSwapHistory";
 import initSwap from "./initSwap";
 import { postSwapAccepted, postSwapCancelled } from "./postSwapState";
 import getExchangeRates from "./getExchangeRates";
-import getProviders from "./getProviders";
+import { maybeTezosAccountUnrevealedAccount } from "./maybeTezosAccountUnrevealedAccount";
 
 export { getAvailableProviders } from "../providers";
 
@@ -34,6 +34,13 @@ export const isSwapOperationPending: (status: string) => boolean = status =>
   !operationStatusList.finishedKO.includes(status);
 
 const getSwapAPIBaseURL: () => string = () => getEnv("SWAP_API_BASE");
+const getSwapUserIP = () => {
+  const SWAP_USER_IP = getEnv("SWAP_USER_IP");
+  if (SWAP_USER_IP) {
+    return { "X-Forwarded-For": SWAP_USER_IP };
+  }
+  return undefined;
+};
 
 const SWAP_API_BASE_PATTERN = /.*\/v(?<version>\d+)\/*$/;
 const getSwapAPIVersion: () => number = () => {
@@ -127,11 +134,12 @@ export const getSwapAPIError = (errorCode: number, errorMessage?: string) => {
 
 export {
   getSwapAPIBaseURL,
+  getSwapUserIP,
   getSwapAPIVersion,
   getCompleteSwapHistory,
   postSwapAccepted,
   getExchangeRates,
-  getProviders,
+  maybeTezosAccountUnrevealedAccount,
   postSwapCancelled,
   initSwap,
   USStates,