chore: improve swap failure messaging & log them to Sentry

src/contexts/SwapProvider/SwapProvider.test.tsx

@@ -13,12 +13,19 @@ import { useWalletContext } from '../WalletProvider';
 import { ChainId } from '@avalabs/core-chains-sdk';
 import { Contract } from 'ethers';
 import Big from 'big.js';
-import { GetRateParams, SwapContextAPI, SwapParams } from './models';
+import {
+  GetRateParams,
+  SwapContextAPI,
+  SwapErrorCode,
+  SwapParams,
+} from './models';
 import { SwapContextProvider, useSwapContext } from './SwapProvider';
 import { useNetworkFeeContext } from '../NetworkFeeProvider';
 import { FeatureGates } from '@src/background/services/featureFlags/models';
 import { SecretType } from '@src/background/services/secrets/models';
 import { RpcMethod } from '@avalabs/vm-module-types';
+import * as swapUtils from './swap-utils';
+import { CommonError } from '@src/utils/errors';
 
 const API_URL = 'https://apiv5.paraswap.io';
 const ACTIVE_ACCOUNT_ADDRESS = 'addressC';
@@ -122,6 +129,10 @@ describe('contexts/SwapProvider', () => {
     jest.resetAllMocks();
     jest.useRealTimers();
 
+    jest
+      .spyOn(swapUtils, 'getParaswapSpender')
+      .mockResolvedValue('0xParaswapContractAddress');
+
     jest.spyOn(global, 'fetch').mockResolvedValue({
       json: async () => ({}),
       ok: true,
@@ -200,7 +211,7 @@ describe('contexts/SwapProvider', () => {
           const { getRate } = getSwapProvider();
 
           await expect(getRate(buildGetRateParams())).rejects.toThrow(
-            'Unsupported network',
+            swapUtils.swapError(CommonError.UnknownNetwork),
           );
         },
       );
@@ -217,7 +228,7 @@ describe('contexts/SwapProvider', () => {
         const { getRate } = getSwapProvider();
 
         await expect(getRate(buildGetRateParams())).rejects.toThrow(
-          'Account address missing',
+          swapUtils.swapError(CommonError.NoActiveAccount),
         );
       });
     });
@@ -308,7 +319,7 @@ describe('contexts/SwapProvider', () => {
         const { getRate } = getSwapProvider();
 
         await expect(getRate(buildGetRateParams())).rejects.toThrow(
-          'Invalid tokens',
+          swapUtils.swapError(CommonError.Unknown, new Error('Invalid tokens')),
         );
 
         expect(global.fetch).toHaveBeenCalledTimes(1);
@@ -379,7 +390,10 @@ describe('contexts/SwapProvider', () => {
       const { swap } = getSwapProvider();
 
       await expect(swap(params)).rejects.toThrow(
-        `Missing parameter: ${paramName}`,
+        swapUtils.swapError(
+          SwapErrorCode.MissingParams,
+          new Error(`Missing parameter: ${paramName}`),
+        ),
       );
     });
 

src/contexts/SwapProvider/SwapProvider.tsx

@@ -29,6 +29,7 @@ import {
   BuildTxParams,
   GetSwapPropsParams,
   ValidTransactionResponse,
+  SwapErrorCode,
 } from './models';
 import Joi from 'joi';
 import { isAPIError } from '@src/pages/Swap/utils';
@@ -37,12 +38,17 @@ import {
   checkForErrorsInBuildTxResult,
   checkForErrorsInGetRateResult,
   ensureAllowance,
+  getParaswapSpender,
   hasEnoughAllowance,
-  throwError,
+  swapError,
   validateParams,
 } from './swap-utils';
 import { assert, assertPresent } from '@src/utils/assertions';
-import { CommonError } from '@src/utils/errors';
+import {
+  CommonError,
+  isUserRejectionError,
+  wrapError,
+} from '@src/utils/errors';
 import { useWalletContext } from '../WalletProvider';
 import { SecretType } from '@src/background/services/secrets/models';
 
@@ -92,10 +98,10 @@ export function SwapContextProvider({ children }: { children: any }) {
       swapSide,
     }: GetRateParams) => {
       if (!activeNetwork || activeNetwork.isTestnet) {
-        throw new Error(`Unsupported network: ${activeNetwork?.chainId}`);
+        throw swapError(CommonError.UnknownNetwork);
       }
       if (!activeAccount || !activeAccount.addressC) {
-        throw new Error('Account address missing');
+        throw swapError(CommonError.NoActiveAccount);
       }
 
       if (!isFlagEnabled(FeatureGates.SWAP)) {
@@ -138,21 +144,6 @@ export function SwapContextProvider({ children }: { children: any }) {
     [activeAccount, activeNetwork, isFlagEnabled, paraswap],
   );
 
-  const getParaswapSpender = useCallback(async () => {
-    if (!isFlagEnabled(FeatureGates.SWAP)) {
-      throw new Error(`Feature (SWAP) is currently unavailable`);
-    }
-
-    const response = await fetch(
-      `${(paraswap as any).apiURL}/adapters/contracts?network=${
-        ChainId.AVALANCHE_MAINNET_ID
-      }`,
-    );
-
-    const result = await response.json();
-    return result.TokenTransferProxy;
-  }, [paraswap, isFlagEnabled]);
-
   const buildTx = useCallback(
     async ({
       network,
@@ -201,7 +192,8 @@ export function SwapContextProvider({ children }: { children: any }) {
           'Content-Type': 'application/json',
         },
         body: JSON.stringify(txConfig),
-      });
+      }).catch(wrapError(swapError(CommonError.NetworkError)));
+
       const transactionParamsOrError: Transaction | APIError =
         await response.json();
       const validationResult = responseSchema.validate(
@@ -210,9 +202,15 @@ export function SwapContextProvider({ children }: { children: any }) {
 
       if (!response.ok || validationResult.error) {
         if (isAPIError(transactionParamsOrError)) {
-          throw new Error(transactionParamsOrError.message);
+          throw swapError(
+            SwapErrorCode.ApiError,
+            new Error(transactionParamsOrError.message),
+          );
         }
-        throw new Error('Invalid transaction params');
+        throw swapError(
+          SwapErrorCode.UnexpectedApiResponse,
+          validationResult.error,
+        );
       }
 
       const txPayload = validationResult.value;
@@ -326,12 +324,12 @@ export function SwapContextProvider({ children }: { children: any }) {
       return {
         srcTokenAddress: srcToken === nativeToken ? ETHER_ADDRESS : srcToken,
         destTokenAddress: destToken === nativeToken ? ETHER_ADDRESS : destToken,
-        spender: await getParaswapSpender(),
+        spender: await getParaswapSpender((paraswap as any).apiURL),
         sourceAmount,
         destinationAmount,
       };
     },
-    [getParaswapSpender],
+    [paraswap],
   );
 
   /**
@@ -437,8 +435,10 @@ export function SwapContextProvider({ children }: { children: any }) {
           }),
         );
 
-        if (batchSignError || !txHashes) {
-          return throwError(batchSignError);
+        if (isUserRejectionError(batchSignError)) {
+          throw batchSignError;
+        } else if (batchSignError || !txHashes) {
+          throw swapError(CommonError.UnableToSign, batchSignError);
         }
 
         swapTxHash = txHashes[txHashes.length - 1];
@@ -450,8 +450,10 @@ export function SwapContextProvider({ children }: { children: any }) {
           }),
         );
 
-        if (signError || !txHash) {
-          return throwError(signError);
+        if (isUserRejectionError(signError)) {
+          throw signError;
+        } else if (signError || !txHash) {
+          throw swapError(CommonError.UnableToSign, signError);
         }
 
         swapTxHash = txHash;
@@ -559,7 +561,7 @@ export function SwapContextProvider({ children }: { children: any }) {
       );
 
       if (txBuildDataError || !swapTx) {
-        throw new Error(`Data Error: ${txBuildDataError}`);
+        throw swapError(SwapErrorCode.CannotBuildTx, txBuildDataError);
       }
 
       const [swapTxHash, signError] = await resolve(
@@ -569,8 +571,10 @@ export function SwapContextProvider({ children }: { children: any }) {
         }),
       );
 
-      if (signError || !swapTxHash) {
-        return throwError(signError);
+      if (isUserRejectionError(signError)) {
+        throw signError;
+      } else if (signError || !swapTxHash) {
+        throw swapError(CommonError.UnableToSign, signError);
       }
 
       notifyOnSwapResult({
@@ -599,6 +603,10 @@ export function SwapContextProvider({ children }: { children: any }) {
 
   const swap = useCallback(
     async (params: SwapParams) => {
+      if (!isFlagEnabled(FeatureGates.SWAP)) {
+        throw new Error(`Feature (SWAP) is currently unavailable`);
+      }
+
       const isOneClickSwapEnabled = isFlagEnabled(FeatureGates.ONE_CLICK_SWAP);
       const isOneClickSwapSupported =
         walletDetails?.type === SecretType.Mnemonic ||

src/contexts/SwapProvider/models.ts

@@ -100,3 +100,13 @@ export type ValidTransactionResponse = {
   gas?: string;
   gasPrice?: string;
 };
+
+export enum SwapErrorCode {
+  MissingParams = 'missing-params',
+  CannotFetchAllowance = 'cannot-fetch-allowance',
+  MissingContractMethod = 'missing-contract-method',
+  ApiError = 'api-error',
+  UnknownSpender = 'unknown-spender',
+  UnexpectedApiResponse = 'unexpected-api-response',
+  CannotBuildTx = 'cannot-build-tx',
+}