@ledgerhq/live-common 34.3.0-nightly.9 → 35.0.0-next.6

package/src/device/use-cases/listAppsUseCase.ts

@@ -44,6 +44,7 @@ export function listAppsUseCase(
         deviceProxyModel: getEnv("DEVICE_PROXY_MODEL") as DeviceModelId,
         managerApiRepository,
         forceProvider: getEnv("FORCE_PROVIDER"),
+        managerDevModeEnabled: getEnv("MANAGER_DEV_MODE"),
       })
     : listAppsV1(transport, deviceInfo, managerApiRepository);
 }

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/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/exchange/providers/swap.ts

@@ -109,6 +109,8 @@ const swapProviders: Record<string, ProviderConfig & AdditionalProviderConfig> =
   },
 };
 
+let providerDataCache: Record<string, ProviderConfig & AdditionalProviderConfig> | null = null;
+
 export const getSwapProvider = async (
   providerName: string,
 ): Promise<ProviderConfig & AdditionalProviderConfig> => {
@@ -162,21 +164,27 @@ export const getProvidersCDNData = async () => {
 };
 
 export const fetchAndMergeProviderData = async () => {
+  if (providerDataCache) {
+    return providerDataCache;
+  }
+
   try {
     const [providersData, providersExtraData] = await Promise.all([
       getProvidersData(),
       getProvidersCDNData(),
     ]);
 
-    // Transform and merge fetched data
     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;
   }
 };

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

@@ -11,8 +11,9 @@ describe("fetchCurrencyAll", () => {
     (network as jest.Mock).mockImplementation(() => ({
       data: fetchCurrencyAllMock,
     }));
+    const providers = ["changelly", "cic", "moonpay", "oneinch", "paraswap"];
 
-    const result = await fetchCurrencyAll({});
+    const result = await fetchCurrencyAll({ providers });
 
     expect(result).toStrictEqual(flattenV5CurrenciesAll(fetchCurrencyAllMock));
     expect(network as jest.Mock).toHaveBeenCalledWith({

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

@@ -12,8 +12,11 @@ describe("fetchCurrencyFrom", () => {
       data: fetchCurrencyFromMock,
     }));
 
+    const providers = ["changelly", "cic", "moonpay", "oneinch", "paraswap"];
+
     const result = await fetchCurrencyFrom({
       currencyTo: "bitcoin",
+      providers,
     });
 
     expect(result).toStrictEqual(flattenV5CurrenciesToAndFrom(fetchCurrencyFromMock));

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

@@ -9,15 +9,16 @@ 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({
       currencyFromId: "bitcoin",
+      providers,
     });
 
     expect(result).toStrictEqual(flattenV5CurrenciesToAndFrom(fetchCurrencyToMock));
@@ -34,6 +35,7 @@ describe("fetchCurrencyFrom", () => {
     try {
       await fetchCurrencyTo({
         currencyFromId: "bitcoin",
+        providers,
       });
     } catch (e) {
       expect(e).toBeInstanceOf(LedgerAPI4xx);

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

@@ -6,11 +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, getSwapUserIP, getAvailableProviders } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 import { getEnv } from "@ledgerhq/live-env";
 
 type Props = {
   additionalCoinsFlag?: boolean;
+  providers: string[];
 };
 
 export type ResponseDataAll = {
@@ -18,11 +19,10 @@ export type ResponseDataAll = {
   to: ResponseDataTo["currencyGroups"];
 };
 
-export async function fetchCurrencyAll({ additionalCoinsFlag = false }: Props) {
+export async function fetchCurrencyAll({ providers, additionalCoinsFlag = false }: Props) {
   if (getEnv("MOCK") || getEnv("PLAYWRIGHT_RUN"))
     return Promise.resolve(flattenV5CurrenciesAll(fetchCurrencyAllMock));
 
-  const providers = getAvailableProviders();
   const url = new URL(`${getSwapAPIBaseURL()}/currencies/all`);
   url.searchParams.append("providers-whitelist", providers.join(","));
   url.searchParams.append("additional-coins-flag", additionalCoinsFlag.toString());

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

@@ -2,11 +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 { getAvailableProviders, getSwapAPIBaseURL, getSwapUserIP } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 import { getEnv } from "@ledgerhq/live-env";
 
 type Props = {
   currencyTo?: string;
+  providers: string[];
   additionalCoinsFlag?: boolean;
 };
 
@@ -17,13 +18,16 @@ export type ResponseData = {
   }>;
 };
 
-export async function fetchCurrencyFrom({ currencyTo, additionalCoinsFlag = false }: Props) {
+export async function fetchCurrencyFrom({
+  currencyTo,
+  providers,
+  additionalCoinsFlag = false,
+}: Props) {
   if (getEnv("MOCK") || getEnv("PLAYWRIGHT_RUN"))
     return flattenV5CurrenciesToAndFrom(fetchCurrencyFromMock);
 
   const headers = getSwapUserIP();
   const url = new URL(`${getSwapAPIBaseURL()}/currencies/from`);
-  const providers = getAvailableProviders();
   url.searchParams.append("providers-whitelist", providers.join(","));
   url.searchParams.append("additional-coins-flag", additionalCoinsFlag.toString());
 

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

@@ -5,10 +5,11 @@ import { DEFAULT_SWAP_TIMEOUT_MS } from "../../const/timeout";
 import axios from "axios";
 import { LedgerAPI4xx } from "@ledgerhq/errors";
 import { flattenV5CurrenciesToAndFrom } from "../../utils/flattenV5CurrenciesToAndFrom";
-import { getAvailableProviders, getSwapAPIBaseURL, getSwapUserIP } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 
 type Props = {
   currencyFromId?: string;
+  providers: string[];
   additionalCoinsFlag?: boolean;
 };
 
@@ -20,13 +21,16 @@ type CurrencyGroup = {
   supportedCurrencies: string[];
 };
 
-export async function fetchCurrencyTo({ currencyFromId, additionalCoinsFlag = false }: Props) {
+export async function fetchCurrencyTo({
+  currencyFromId,
+  providers,
+  additionalCoinsFlag = false,
+}: Props) {
   if (isIntegrationTestEnv())
     return Promise.resolve(flattenV5CurrenciesToAndFrom(fetchCurrencyToMock));
 
   const url = new URL(`${getSwapAPIBaseURL()}/currencies/to`);
 
-  const providers = getAvailableProviders();
   url.searchParams.append("providers-whitelist", providers.join(","));
   url.searchParams.append("additional-coins-flag", additionalCoinsFlag.toString());
   url.searchParams.append("currency-from", currencyFromId!);

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

@@ -8,10 +8,10 @@ import { SwapGenericAPIError } from "../../../../errors";
 import { enrichRatesResponse } from "../../utils/enrichRatesResponse";
 import { isIntegrationTestEnv } from "../../utils/isIntegrationTestEnv";
 import { fetchRatesMock } from "./__mocks__/fetchRates.mocks";
-import { getAvailableProviders, getSwapAPIBaseURL, getSwapUserIP } from "../..";
+import { getSwapAPIBaseURL, getSwapUserIP } from "../..";
 
 type Props = {
-  removeProviders: Array<string>;
+  providers: Array<string>;
   currencyFrom?: string;
   toCurrencyId?: string;
   fromCurrencyAmount: string;
@@ -76,7 +76,7 @@ export const throwRateError = (response: ExchangeRate[]) => {
 };
 
 export async function fetchRates({
-  removeProviders,
+  providers,
   currencyFrom,
   toCurrencyId,
   unitTo,
@@ -90,10 +90,6 @@ export async function fetchRates({
   }
 
   const url = new URL(`${getSwapAPIBaseURL()}/rate`);
-  const providers = await getAvailableProviders();
-  removeProviders.forEach(provider => {
-    providers.splice(providers.indexOf(provider), 1);
-  });
   const requestBody = {
     from: currencyFrom,
     to: toCurrencyId,

package/src/exchange/swap/completeExchange.ts

@@ -24,6 +24,7 @@ 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))));
@@ -74,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";

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/v5/useFetchCurrencyAll.ts

@@ -1,17 +1,21 @@
 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: {
       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,6 +1,7 @@
 import { useFeature } from "../../../../featureFlags";
 import { useAPI } from "../../../../hooks/useAPI";
 import { fetchCurrencyFrom } from "../../api/v5/fetchCurrencyFrom";
+import { useFilteredProviders } from "./useFilteredProviders";
 
 type Props = {
   currencyTo?: string;
@@ -10,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: {
       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

@@ -4,6 +4,7 @@ import { getAccountCurrency } from "@ledgerhq/coin-framework/account/helpers";
 import { fetchCurrencyTo } from "../../api/v5";
 import { useAPI } from "../../../../hooks/useAPI";
 import { useFeature } from "../../../../featureFlags";
+import { useFilteredProviders } from "./useFilteredProviders";
 
 type Props = {
   fromCurrencyAccount: AccountLike | undefined;
@@ -12,6 +13,7 @@ type Props = {
 
 export function useFetchCurrencyTo({ fromCurrencyAccount }: Props) {
   const fetchAdditionalCoins = useFeature("fetchAdditionalCoins");
+  const { providers, loading, error } = useFilteredProviders();
 
   const currencyFromId = fromCurrencyAccount
     ? getAccountCurrency(fromCurrencyAccount).id
@@ -21,10 +23,10 @@ export function useFetchCurrencyTo({ fromCurrencyAccount }: Props) {
     queryFn: fetchCurrencyTo,
     queryProps: {
       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,17 +1,18 @@
-import { AccountLike } from "@ledgerhq/types-live";
 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({
@@ -19,25 +20,22 @@ export function useFetchRates({
   toCurrency,
   fromCurrencyAmount,
   onSuccess,
+  isEnabled = true,
 }: Props) {
   const currencyFrom = fromCurrencyAccount ? getAccountCurrency(fromCurrencyAccount).id : undefined;
   const unitFrom = fromCurrencyAccount
     ? getAccountCurrency(fromCurrencyAccount).units[0]
     : undefined;
   const unitTo = toCurrency?.units[0];
-  const moonpayFF = useFeature("ptxSwapMoonpayProvider");
-  const removeProviders: string[] = [];
   const formattedCurrencyAmount =
     (unitFrom && `${fromCurrencyAmount.shiftedBy(-unitFrom.magnitude)}`) ?? "0";
+  const { providers, loading, error } = useFilteredProviders();
 
-  if (!moonpayFF?.enabled) {
-    removeProviders.push("moonpay");
-  }
   const toCurrencyId = toCurrency?.id;
   return useAPI({
     queryFn: fetchRates,
     queryProps: {
-      removeProviders: [],
+      providers,
       unitTo: unitTo!,
       unitFrom: unitFrom!,
       currencyFrom,
@@ -45,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/initSwap.ts

@@ -30,6 +30,7 @@ import { decodePayloadProtobuf } from "@ledgerhq/hw-app-exchange";
 import { getSwapProvider } from "../providers";
 import { convertToAppExchangePartnerKey } from "../providers";
 import { getDefaultAccountName } from "@ledgerhq/live-wallet/accountName";
+import { TronSendTrc20ToNewAccountForbidden } from "../../families/tron/errors";
 
 const withDevicePromise = (deviceId, fn) =>
   firstValueFrom(withDevice(deviceId)(transport => from(fn(transport))));
@@ -160,7 +161,10 @@ const initSwap = (input: InitSwapInput): Observable<SwapRequestEvent> => {
           transaction,
         );
         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

package/src/families/cosmos/bridge/mock.ts

@@ -103,7 +103,7 @@ const prepareTransaction = async (a: CosmosAccount, t: Transaction): Promise<Tra
     return {
       ...t,
       gas: new BigNumber(1),
-      fees: new BigNumber(500),
+      fees: new BigNumber(375),
       networkInfo: {
         family: "cosmos",
         fees: new BigNumber(500),