From 328168a26341fabd86a0f79ff650e02d24018e8f Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 7 Aug 2023 21:18:49 +0100
Subject: [PATCH 01/29] swaps when amount is insufficient

---
 app/components/UI/Swaps/index.js              | 32 ++++++++-
 app/components/Views/SendFlow/Amount/index.js | 70 ++++++++++++++++++-
 2 files changed, 100 insertions(+), 2 deletions(-)

diff --git a/app/components/UI/Swaps/index.js b/app/components/UI/Swaps/index.js
index 73af0449289..056aada1af9 100644
--- a/app/components/UI/Swaps/index.js
+++ b/app/components/UI/Swaps/index.js
@@ -206,6 +206,8 @@ function SwapsAmountView({
 
   const explorer = useBlockExplorer(providerConfig, frequentRpcList);
   const initialSource = route.params?.sourceToken ?? SWAPS_NATIVE_ADDRESS;
+  const initialDestination = route.params?.destinationToken;
+
   const [amount, setAmount] = useState('0');
   const [slippage, setSlippage] = useState(AppConstants.SWAPS.DEFAULT_SLIPPAGE);
   const [isInitialLoadingTokens, setInitialLoadingTokens] = useState(false);
@@ -217,13 +219,18 @@ function SwapsAmountView({
       ),
     ),
   );
+  const [isDestinationSet, setIsDestinationSet] = useState(false);
 
   const [sourceToken, setSourceToken] = useState(() =>
     swapsTokens?.find((token) =>
       toLowerCaseEquals(token.address, initialSource),
     ),
   );
-  const [destinationToken, setDestinationToken] = useState(null);
+  const [destinationToken, setDestinationToken] = useState(
+    swapsTokens?.find((token) =>
+      toLowerCaseEquals(token.address, initialDestination),
+    ),
+  );
   const [hasDismissedTokenAlert, setHasDismissedTokenAlert] = useState(true);
   const [contractBalance, setContractBalance] = useState(null);
   const [contractBalanceAsUnits, setContractBalanceAsUnits] = useState(
@@ -365,6 +372,29 @@ function SwapsAmountView({
     swapsTokens,
   ]);
 
+  useEffect(() => {
+    if (
+      !isDestinationSet &&
+      initialDestination &&
+      swapsControllerTokens &&
+      swapsTokens?.length > 0 &&
+      !destinationToken
+    ) {
+      setIsDestinationSet(true);
+      setDestinationToken(
+        swapsTokens.find((token) =>
+          toLowerCaseEquals(token.address, initialDestination),
+        ),
+      );
+    }
+  }, [
+    initialDestination,
+    isDestinationSet,
+    destinationToken,
+    swapsControllerTokens,
+    swapsTokens,
+  ]);
+
   useEffect(() => {
     setHasDismissedTokenAlert(false);
   }, [destinationToken]);
diff --git a/app/components/Views/SendFlow/Amount/index.js b/app/components/Views/SendFlow/Amount/index.js
index cd66328afbb..5308437edb5 100644
--- a/app/components/Views/SendFlow/Amount/index.js
+++ b/app/components/Views/SendFlow/Amount/index.js
@@ -89,6 +89,7 @@ import {
 } from '../../../../../wdio/screen-objects/testIDs/Screens/AmountScreen.testIds.js';
 import generateTestId from '../../../../../wdio/utils/generateTestId';
 import {
+  selectChainId,
   selectProviderType,
   selectTicker,
 } from '../../../../selectors/networkController';
@@ -103,6 +104,13 @@ import { selectContractBalances } from '../../../../selectors/tokenBalancesContr
 import { selectSelectedAddress } from '../../../../selectors/preferencesController';
 import { PREFIX_HEX_STRING } from '../../../../constants/transaction';
 import Routes from '../../../../constants/navigation/Routes';
+import Button from '../../../../component-library/components/Buttons/Button/Button';
+import { ButtonVariants } from '../../../../component-library/components/Buttons/Button';
+import { isNetworkBuySupported } from '../../../UI/Ramp/utils';
+import { getRampNetworks } from '../../../../reducers/fiatOrders';
+import { swapsLivenessSelector } from '../../../../reducers/swaps';
+import { isSwapsAllowed } from '../../../../components/UI/Swaps/utils';
+import { swapsUtils } from '@metamask/swaps-controller';
 
 const KEYBOARD_OFFSET = Device.isSmallDevice() ? 80 : 120;
 
@@ -342,6 +350,7 @@ const createStyles = (colors) =>
       marginTop: 20,
       marginHorizontal: 20,
     },
+    swapOrBuyButton: { width: '100%', marginTop: 16 },
   });
 
 /**
@@ -437,6 +446,18 @@ class Amount extends PureComponent {
      * Resets transaction state
      */
     resetTransaction: PropTypes.func,
+    /**
+     * Boolean that indicates if the network supports buy
+     */
+    isNetworkBuySupported: PropTypes.bool,
+    /**
+     * Boolean that indicates if the swap is live
+     */
+    swapsIsLive: PropTypes.bool,
+    /**
+     * String that indicates the current chain id
+     */
+    chainId: PropTypes.string,
   };
 
   state = {
@@ -1191,10 +1212,30 @@ class Amount extends PureComponent {
       internalPrimaryCurrencyIsCrypto,
       currentBalance,
     } = this.state;
-    const { currentCurrency } = this.props;
+    const {
+      currentCurrency,
+      selectedAsset,
+      navigation,
+      isNetworkBuySupported,
+      swapsIsLive,
+      chainId,
+    } = this.props;
     const colors = this.context.colors || mockTheme.colors;
     const themeAppearance = this.context.themeAppearance || 'light';
     const styles = createStyles(colors);
+    const navigateToSwap = () => {
+      navigation.replace('Swaps', {
+        screen: 'SwapsAmountView',
+        params: {
+          sourceToken: swapsUtils.NATIVE_SWAPS_TOKEN_ADDRESS,
+          destinationToken: selectedAsset.address,
+        },
+      });
+    };
+
+    const navigateToBuy = () => {
+      navigation.navigate(Routes.FIAT_ON_RAMP_AGGREGATOR.ID);
+    };
 
     return (
       <View>
@@ -1259,6 +1300,27 @@ class Amount extends PureComponent {
             {...generateTestId(Platform, AMOUNT_ERROR)}
           >
             <ErrorMessage errorMessage={amountError} />
+            {isNetworkBuySupported && selectedAsset.isETH && (
+              <Button
+                variant={ButtonVariants.Primary}
+                label={strings('asset_overview.buy_button')}
+                onPress={navigateToBuy}
+                style={styles.swapOrBuyButton}
+              />
+            )}
+
+            {!selectedAsset.isETH &&
+              AppConstants.SWAPS.ACTIVE &&
+              swapsIsLive &&
+              isSwapsAllowed(chainId) &&
+              amountError === strings('transaction.insufficient') && (
+                <Button
+                  variant={ButtonVariants.Primary}
+                  label={'Swap'}
+                  onPress={navigateToSwap}
+                  style={styles.swapOrBuyButton}
+                />
+              )}
           </View>
         )}
       </View>
@@ -1430,6 +1492,12 @@ const mapStateToProps = (state, ownProps) => ({
   transactionState: ownProps.transaction || state.transaction,
   selectedAsset: state.transaction.selectedAsset,
   isPaymentRequest: state.transaction.paymentRequest,
+  isNetworkBuySupported: isNetworkBuySupported(
+    selectChainId(state),
+    getRampNetworks(state),
+  ),
+  swapsIsLive: swapsLivenessSelector(state),
+  chainId: selectChainId(state),
 });
 
 const mapDispatchToProps = (dispatch) => ({

From 9f41fa469dbfe70dfa7f686091d65a4e65a13d12 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 15 Sep 2023 22:00:19 +0100
Subject: [PATCH 02/29] added new label swap tokens and re used the warning of
 transactions modal to buy tokens

---
 .../Amount/__snapshots__/index.test.tsx.snap  | 98 ++++++-------------
 app/components/Views/SendFlow/Amount/index.js | 53 +++++++---
 locales/languages/en.json                     |  3 +-
 3 files changed, 69 insertions(+), 85 deletions(-)

diff --git a/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap b/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap
index 5fe600e3d3a..ebbdc8920d7 100644
--- a/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap
+++ b/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap
@@ -7752,80 +7752,38 @@ exports[`Amount should show an error message if balance is insufficient 1`] = `
                                 }
                                 testID="amount-error"
                               >
-                                <View
+                                <TouchableOpacity
+                                  onPress={[Function]}
                                   style={
-                                    Array [
-                                      Object {
-                                        "borderRadius": 8,
-                                        "borderWidth": 1,
-                                        "flexDirection": "row",
-                                        "paddingHorizontal": 12,
-                                        "paddingVertical": 8,
-                                      },
-                                      undefined,
-                                      Object {
-                                        "backgroundColor": "#D7384719",
-                                        "borderColor": "#D73847",
-                                      },
-                                      undefined,
-                                    ]
+                                    Object {
+                                      "alignItems": "center",
+                                      "backgroundColor": "#D7384719",
+                                      "borderColor": "#D73847",
+                                      "borderRadius": 8,
+                                      "borderWidth": 1,
+                                      "justifyContent": "center",
+                                      "marginHorizontal": 24,
+                                      "marginTop": 12,
+                                      "paddingHorizontal": 10,
+                                      "paddingVertical": 6,
+                                    }
                                   }
-                                  testID="error-message-warning"
                                 >
-                                  <View>
-                                    <Text
-                                      style={
-                                        Array [
-                                          Object {
-                                            "color": "#24272A",
-                                            "fontFamily": "EuclidCircularB-Regular",
-                                            "fontSize": 30,
-                                            "fontWeight": "400",
-                                            "marginVertical": 2,
-                                          },
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          Object {
-                                            "fontSize": 12,
-                                          },
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          undefined,
-                                          Array [
-                                            Object {
-                                              "color": "#24272A",
-                                              "flex": 1,
-                                              "fontSize": 14,
-                                              "lineHeight": 17,
-                                            },
-                                            Object {
-                                              "flex": 0,
-                                            },
-                                          ],
-                                        ]
+                                  <Text
+                                    style={
+                                      Object {
+                                        "color": "#24272A",
+                                        "fontFamily": "EuclidCircularB-Regular",
+                                        "fontSize": 12,
+                                        "fontWeight": "400",
+                                        "lineHeight": 16,
+                                        "textAlign": "center",
                                       }
-                                    >
-                                      Insufficient funds
-                                    </Text>
-                                  </View>
-                                </View>
+                                    }
+                                  >
+                                    Insufficient funds
+                                  </Text>
+                                </TouchableOpacity>
                               </View>
                             </View>
                           </View>
diff --git a/app/components/Views/SendFlow/Amount/index.js b/app/components/Views/SendFlow/Amount/index.js
index 5308437edb5..44893f1534f 100644
--- a/app/components/Views/SendFlow/Amount/index.js
+++ b/app/components/Views/SendFlow/Amount/index.js
@@ -106,7 +106,7 @@ import { PREFIX_HEX_STRING } from '../../../../constants/transaction';
 import Routes from '../../../../constants/navigation/Routes';
 import Button from '../../../../component-library/components/Buttons/Button/Button';
 import { ButtonVariants } from '../../../../component-library/components/Buttons/Button';
-import { isNetworkBuySupported } from '../../../UI/Ramp/utils';
+import { isNetworkBuyNativeTokenSupported } from '../../../UI/Ramp/utils';
 import { getRampNetworks } from '../../../../reducers/fiatOrders';
 import { swapsLivenessSelector } from '../../../../reducers/swaps';
 import { isSwapsAllowed } from '../../../../components/UI/Swaps/utils';
@@ -296,6 +296,18 @@ const createStyles = (colors) =>
     errorMessageWrapper: {
       marginVertical: 16,
     },
+    errorBuyWrapper: {
+      marginHorizontal: 24,
+      marginTop: 12,
+      paddingHorizontal: 10,
+      paddingVertical: 6,
+      backgroundColor: colors.error.muted,
+      borderColor: colors.error.default,
+      borderRadius: 8,
+      borderWidth: 1,
+      justifyContent: 'center',
+      alignItems: 'center',
+    },
     CollectibleMedia: {
       width: 120,
       height: 120,
@@ -351,6 +363,17 @@ const createStyles = (colors) =>
       marginHorizontal: 20,
     },
     swapOrBuyButton: { width: '100%', marginTop: 16 },
+    error: {
+      color: colors.text.default,
+      fontSize: 12,
+      lineHeight: 16,
+      ...fontStyles.normal,
+      textAlign: 'center',
+    },
+    underline: {
+      textDecorationLine: 'underline',
+      ...fontStyles.bold,
+    },
   });
 
 /**
@@ -449,7 +472,7 @@ class Amount extends PureComponent {
     /**
      * Boolean that indicates if the network supports buy
      */
-    isNetworkBuySupported: PropTypes.bool,
+    isNetworkBuyNativeTokenSupported: PropTypes.bool,
     /**
      * Boolean that indicates if the swap is live
      */
@@ -1216,7 +1239,7 @@ class Amount extends PureComponent {
       currentCurrency,
       selectedAsset,
       navigation,
-      isNetworkBuySupported,
+      isNetworkBuyNativeTokenSupported,
       swapsIsLive,
       chainId,
     } = this.props;
@@ -1299,15 +1322,17 @@ class Amount extends PureComponent {
             style={styles.errorMessageWrapper}
             {...generateTestId(Platform, AMOUNT_ERROR)}
           >
-            <ErrorMessage errorMessage={amountError} />
-            {isNetworkBuySupported && selectedAsset.isETH && (
-              <Button
-                variant={ButtonVariants.Primary}
-                label={strings('asset_overview.buy_button')}
-                onPress={navigateToBuy}
-                style={styles.swapOrBuyButton}
-              />
-            )}
+            <TouchableOpacity
+              onPress={navigateToBuy}
+              style={styles.errorBuyWrapper}
+            >
+              <Text style={styles.error}>{amountError}</Text>
+              {isNetworkBuyNativeTokenSupported && selectedAsset.isETH && (
+                <Text style={[styles.error, styles.underline]}>
+                  {strings('transaction.buy_more')}
+                </Text>
+              )}
+            </TouchableOpacity>
 
             {!selectedAsset.isETH &&
               AppConstants.SWAPS.ACTIVE &&
@@ -1316,7 +1341,7 @@ class Amount extends PureComponent {
               amountError === strings('transaction.insufficient') && (
                 <Button
                   variant={ButtonVariants.Primary}
-                  label={'Swap'}
+                  label={strings('transaction.swap_tokens')}
                   onPress={navigateToSwap}
                   style={styles.swapOrBuyButton}
                 />
@@ -1492,7 +1517,7 @@ const mapStateToProps = (state, ownProps) => ({
   transactionState: ownProps.transaction || state.transaction,
   selectedAsset: state.transaction.selectedAsset,
   isPaymentRequest: state.transaction.paymentRequest,
-  isNetworkBuySupported: isNetworkBuySupported(
+  isNetworkBuyNativeTokenSupported: isNetworkBuyNativeTokenSupported(
     selectChainId(state),
     getRampNetworks(state),
   ),
diff --git a/locales/languages/en.json b/locales/languages/en.json
index 901cc4fbc5d..17ce0c74fec 100644
--- a/locales/languages/en.json
+++ b/locales/languages/en.json
@@ -1110,7 +1110,8 @@
     "fiat_conversion_not_available": "Fiat conversions are not available at this moment",
     "hex_data_copied": "Hex data copied to clipboard",
     "invalid_recipient": "Invalid recipient",
-    "invalid_recipient_description": "Check the address and make sure it's valid"
+    "invalid_recipient_description": "Check the address and make sure it's valid",
+    "swap_tokens": "Swap tokens"
   },
   "custom_gas": {
     "total": "Total",

From 350d2cafc2e7afb693129ae643af80e44d80a489 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 9 Oct 2023 19:59:57 +0100
Subject: [PATCH 03/29] add events for metrics purposes, remove swaps button
 and added the navigation to the insufficient funds message

---
 app/components/Views/SendFlow/Amount/index.js | 47 ++++++++++++-------
 app/core/Analytics/MetaMetrics.events.ts      |  4 ++
 2 files changed, 35 insertions(+), 16 deletions(-)

diff --git a/app/components/Views/SendFlow/Amount/index.js b/app/components/Views/SendFlow/Amount/index.js
index fd458c0ad61..86d6fcc28ee 100644
--- a/app/components/Views/SendFlow/Amount/index.js
+++ b/app/components/Views/SendFlow/Amount/index.js
@@ -1257,8 +1257,26 @@ class Amount extends PureComponent {
       });
     };
 
-    const navigateToBuy = () => {
-      navigation.navigate(Routes.FIAT_ON_RAMP_AGGREGATOR.ID);
+    const navigateToBuyOrSwaps = () => {
+      if (
+        !selectedAsset.isETH &&
+        AppConstants.SWAPS.ACTIVE &&
+        swapsIsLive &&
+        isSwapsAllowed(chainId) &&
+        amountError === strings('transaction.insufficient')
+      ) {
+        Analytics.trackEventWithParameters(MetaMetricsEvents.LINK_CLICKED, {
+          location: 'insufficient_funds_warning',
+          text: 'swap_tokens',
+        });
+        navigateToSwap();
+      } else if (isNetworkBuyNativeTokenSupported && selectedAsset.isETH) {
+        Analytics.trackEventWithParameters(MetaMetricsEvents.LINK_CLICKED, {
+          location: 'insufficient_funds_warning',
+          text: 'buy_more',
+        });
+        navigation.navigate(Routes.FIAT_ON_RAMP_AGGREGATOR.ID);
+      }
     };
 
     return (
@@ -1324,7 +1342,7 @@ class Amount extends PureComponent {
             {...generateTestId(Platform, AMOUNT_ERROR)}
           >
             <TouchableOpacity
-              onPress={navigateToBuy}
+              onPress={navigateToBuyOrSwaps}
               style={styles.errorBuyWrapper}
             >
               <Text style={styles.error}>{amountError}</Text>
@@ -1333,20 +1351,17 @@ class Amount extends PureComponent {
                   {strings('transaction.buy_more')}
                 </Text>
               )}
-            </TouchableOpacity>
 
-            {!selectedAsset.isETH &&
-              AppConstants.SWAPS.ACTIVE &&
-              swapsIsLive &&
-              isSwapsAllowed(chainId) &&
-              amountError === strings('transaction.insufficient') && (
-                <Button
-                  variant={ButtonVariants.Primary}
-                  label={strings('transaction.swap_tokens')}
-                  onPress={navigateToSwap}
-                  style={styles.swapOrBuyButton}
-                />
-              )}
+              {!selectedAsset.isETH &&
+                AppConstants.SWAPS.ACTIVE &&
+                swapsIsLive &&
+                isSwapsAllowed(chainId) &&
+                amountError === strings('transaction.insufficient') && (
+                  <Text style={[styles.error, styles.underline]}>
+                    {strings('transaction.swap_tokens')}
+                  </Text>
+                )}
+            </TouchableOpacity>
           </View>
         )}
       </View>
diff --git a/app/core/Analytics/MetaMetrics.events.ts b/app/core/Analytics/MetaMetrics.events.ts
index a86858a21b6..994d4182b3c 100644
--- a/app/core/Analytics/MetaMetrics.events.ts
+++ b/app/core/Analytics/MetaMetrics.events.ts
@@ -85,6 +85,9 @@ enum EVENT_NAME {
   // Portfolio
   PORTFOLIO_LINK_CLICKED = 'Portfolio Link Clicked',
 
+  // Link redirects
+  LINK_CLICKED = 'Link Clicked',
+
   // On-ramp [LEGACY]
   ONRAMP_OPENED = 'On-ramp Opened',
   ONRAMP_CLOSED = 'On-ramp Closed',
@@ -417,6 +420,7 @@ const events = {
     EVENT_NAME.ONRAMP_PURCHASE_COMPLETED_LEGACY,
   ),
   PORTFOLIO_LINK_CLICKED: generateOpt(EVENT_NAME.PORTFOLIO_LINK_CLICKED),
+  LINK_CLICKED: generateOpt(EVENT_NAME.LINK_CLICKED),
   WALLET_SECURITY_STARTED: generateOpt(EVENT_NAME.WALLET_SECURITY_STARTED),
   WALLET_SECURITY_MANUAL_BACKUP_INITIATED: generateOpt(
     EVENT_NAME.WALLET_SECURITY_MANUAL_BACKUP_INITIATED,

From 841b44d49816b6d4874deec33246c9d23a6e5564 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Tue, 10 Oct 2023 11:12:28 +0100
Subject: [PATCH 04/29] remove unused imports

---
 app/components/Views/SendFlow/Amount/index.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/app/components/Views/SendFlow/Amount/index.js b/app/components/Views/SendFlow/Amount/index.js
index 86d6fcc28ee..7b580692e5a 100644
--- a/app/components/Views/SendFlow/Amount/index.js
+++ b/app/components/Views/SendFlow/Amount/index.js
@@ -104,8 +104,6 @@ import { selectContractBalances } from '../../../../selectors/tokenBalancesContr
 import { selectSelectedAddress } from '../../../../selectors/preferencesController';
 import { PREFIX_HEX_STRING } from '../../../../constants/transaction';
 import Routes from '../../../../constants/navigation/Routes';
-import Button from '../../../../component-library/components/Buttons/Button/Button';
-import { ButtonVariants } from '../../../../component-library/components/Buttons/Button';
 import { isNetworkBuyNativeTokenSupported } from '../../../UI/Ramp/utils';
 import { getRampNetworks } from '../../../../reducers/fiatOrders';
 import { swapsLivenessSelector } from '../../../../reducers/swaps';

From 91b9bf3e4a8816d84db45f3048e0d8808ee16ed4 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 12 Oct 2023 21:03:54 +0100
Subject: [PATCH 05/29] address review, by changing conditions into variables
 for better self explanatory meaning

---
 app/components/UI/Swaps/index.js              | 23 ++++++---------
 app/components/Views/SendFlow/Amount/index.js | 29 +++++++++----------
 2 files changed, 22 insertions(+), 30 deletions(-)

diff --git a/app/components/UI/Swaps/index.js b/app/components/UI/Swaps/index.js
index 203d529768f..110ec1eeada 100644
--- a/app/components/UI/Swaps/index.js
+++ b/app/components/UI/Swaps/index.js
@@ -352,14 +352,15 @@ function SwapsAmountView({
     })();
   }, [swapsControllerTokens, swapsTokens]);
 
+  const canSetAnInitialTokenDestination =
+    !isSourceSet &&
+    initialSource &&
+    swapsControllerTokens &&
+    swapsTokens?.length > 0 &&
+    !sourceToken;
+
   useEffect(() => {
-    if (
-      !isSourceSet &&
-      initialSource &&
-      swapsControllerTokens &&
-      swapsTokens?.length > 0 &&
-      !sourceToken
-    ) {
+    if (canSetAnInitialTokenDestination) {
       setIsSourceSet(true);
       setSourceToken(
         swapsTokens.find((token) =>
@@ -367,13 +368,7 @@ function SwapsAmountView({
         ),
       );
     }
-  }, [
-    initialSource,
-    isSourceSet,
-    sourceToken,
-    swapsControllerTokens,
-    swapsTokens,
-  ]);
+  }, [canSetAnInitialTokenDestination, initialSource, swapsTokens]);
 
   useEffect(() => {
     if (
diff --git a/app/components/Views/SendFlow/Amount/index.js b/app/components/Views/SendFlow/Amount/index.js
index 7b580692e5a..25842bd700e 100644
--- a/app/components/Views/SendFlow/Amount/index.js
+++ b/app/components/Views/SendFlow/Amount/index.js
@@ -1255,14 +1255,15 @@ class Amount extends PureComponent {
       });
     };
 
+    const isSwappable =
+      !selectedAsset.isETH &&
+      AppConstants.SWAPS.ACTIVE &&
+      swapsIsLive &&
+      isSwapsAllowed(chainId) &&
+      amountError === strings('transaction.insufficient');
+
     const navigateToBuyOrSwaps = () => {
-      if (
-        !selectedAsset.isETH &&
-        AppConstants.SWAPS.ACTIVE &&
-        swapsIsLive &&
-        isSwapsAllowed(chainId) &&
-        amountError === strings('transaction.insufficient')
-      ) {
+      if (isSwappable) {
         Analytics.trackEventWithParameters(MetaMetricsEvents.LINK_CLICKED, {
           location: 'insufficient_funds_warning',
           text: 'swap_tokens',
@@ -1350,15 +1351,11 @@ class Amount extends PureComponent {
                 </Text>
               )}
 
-              {!selectedAsset.isETH &&
-                AppConstants.SWAPS.ACTIVE &&
-                swapsIsLive &&
-                isSwapsAllowed(chainId) &&
-                amountError === strings('transaction.insufficient') && (
-                  <Text style={[styles.error, styles.underline]}>
-                    {strings('transaction.swap_tokens')}
-                  </Text>
-                )}
+              {isSwappable && (
+                <Text style={[styles.error, styles.underline]}>
+                  {strings('transaction.swap_tokens')}
+                </Text>
+              )}
             </TouchableOpacity>
           </View>
         )}

From 8ae884c4dfb59b0cdc67bfb85886ded46a8a8ad4 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 13 Oct 2023 15:06:20 +0100
Subject: [PATCH 06/29] refactor for better variable names

---
 app/components/UI/Swaps/index.js | 29 ++++++++++++-----------------
 1 file changed, 12 insertions(+), 17 deletions(-)

diff --git a/app/components/UI/Swaps/index.js b/app/components/UI/Swaps/index.js
index 110ec1eeada..dd7f8a6cc4e 100644
--- a/app/components/UI/Swaps/index.js
+++ b/app/components/UI/Swaps/index.js
@@ -352,7 +352,7 @@ function SwapsAmountView({
     })();
   }, [swapsControllerTokens, swapsTokens]);
 
-  const canSetAnInitialTokenDestination =
+  const canSetAnInitialSourceToken =
     !isSourceSet &&
     initialSource &&
     swapsControllerTokens &&
@@ -360,7 +360,7 @@ function SwapsAmountView({
     !sourceToken;
 
   useEffect(() => {
-    if (canSetAnInitialTokenDestination) {
+    if (canSetAnInitialSourceToken) {
       setIsSourceSet(true);
       setSourceToken(
         swapsTokens.find((token) =>
@@ -368,16 +368,17 @@ function SwapsAmountView({
         ),
       );
     }
-  }, [canSetAnInitialTokenDestination, initialSource, swapsTokens]);
+  }, [canSetAnInitialSourceToken, initialSource, swapsTokens]);
+
+  const canSetAnInitialTokenDestination =
+    !isDestinationSet &&
+    initialDestination &&
+    swapsControllerTokens &&
+    swapsTokens?.length > 0 &&
+    !destinationToken;
 
   useEffect(() => {
-    if (
-      !isDestinationSet &&
-      initialDestination &&
-      swapsControllerTokens &&
-      swapsTokens?.length > 0 &&
-      !destinationToken
-    ) {
+    if (canSetAnInitialTokenDestination) {
       setIsDestinationSet(true);
       setDestinationToken(
         swapsTokens.find((token) =>
@@ -385,13 +386,7 @@ function SwapsAmountView({
         ),
       );
     }
-  }, [
-    initialDestination,
-    isDestinationSet,
-    destinationToken,
-    swapsControllerTokens,
-    swapsTokens,
-  ]);
+  }, [canSetAnInitialTokenDestination, initialDestination, swapsTokens]);
 
   useEffect(() => {
     setHasDismissedTokenAlert(false);

From b67ff9dc4f393ec33dea93352fc980d3906a3668 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 16 Oct 2023 15:08:54 +0100
Subject: [PATCH 07/29] added a new json rpc called wallet_swap, to enable
 dapps to ask for a swap amount from one to another token

---
 app/components/UI/Swaps/index.js              |  10 ++
 .../RPCMethods/RPCMethodMiddleware.test.ts    | 139 +++++++++++++++++-
 app/core/RPCMethods/RPCMethodMiddleware.ts    |  49 +++++-
 app/core/RPCMethods/utils.ts                  |  18 +++
 4 files changed, 213 insertions(+), 3 deletions(-)

diff --git a/app/components/UI/Swaps/index.js b/app/components/UI/Swaps/index.js
index dd7f8a6cc4e..e228d941a47 100644
--- a/app/components/UI/Swaps/index.js
+++ b/app/components/UI/Swaps/index.js
@@ -210,6 +210,7 @@ function SwapsAmountView({
   const explorer = useBlockExplorer(providerConfig, networkConfigurations);
   const initialSource = route.params?.sourceToken ?? SWAPS_NATIVE_ADDRESS;
   const initialDestination = route.params?.destinationToken;
+  const initialAmount = route.params?.amount;
 
   const [amount, setAmount] = useState('0');
   const [slippage, setSlippage] = useState(AppConstants.SWAPS.DEFAULT_SLIPPAGE);
@@ -388,6 +389,15 @@ function SwapsAmountView({
     }
   }, [canSetAnInitialTokenDestination, initialDestination, swapsTokens]);
 
+  const canSetInitialAmount =
+    destinationToken && sourceToken && initialAmount && swapsControllerTokens;
+
+  useEffect(() => {
+    if (canSetInitialAmount) {
+      setAmount(parseInt(initialAmount, 16).toString());
+    }
+  }, [initialAmount, canSetInitialAmount]);
+
   useEffect(() => {
     setHasDismissedTokenAlert(false);
   }, [destinationToken]);
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index 2d954f58395..47f6c356aa5 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -86,7 +86,10 @@ function assertIsJsonRpcSuccess(
     throw new Error(`Response is missing 'result' property`);
   }
 }
-
+// Mock the navigation object.
+const navigation = {
+  navigate: jest.fn(),
+};
 /**
  * Return a minimal set of options for `getRpcMethodMiddleware`. These options
  * are complete enough to test at least some method handlers, and they are type-
@@ -98,7 +101,7 @@ function getMinimalOptions() {
   return {
     hostname: '',
     getProviderState: jest.fn(),
-    navigation: jest.fn(),
+    navigation,
     url: { current: '' },
     title: { current: '' },
     icon: { current: undefined },
@@ -1141,4 +1144,136 @@ describe('getRpcMethodMiddleware', () => {
       expect(spy).toBeCalledTimes(1);
     });
   });
+  describe('wallet_swap', () => {
+    it('should throw error if chainId is not consistent between from and to', async () => {
+      const middleware = getRpcMethodMiddleware({
+        ...getMinimalOptions(),
+        hostname: 'example.metamask.io',
+      });
+      const request = {
+        jsonrpc,
+        id: 1,
+        method: 'wallet_swap',
+        params: [
+          {
+            from: {
+              chainId: '0x2',
+              // DAI address
+              token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+              amount: '0x10',
+            },
+            to: {
+              chainId: '0x1',
+              // ETH address
+              token_address: '0x0000000000000000000000000000000000000000',
+            },
+          },
+        ],
+      };
+      const response = await callMiddleware({ middleware, request });
+      await expect(response?.error?.message).toStrictEqual(
+        'ChainId value is not consistent between from and to',
+      );
+    });
+
+    it('should throw error if chainId, from property does not have chainId property', async () => {
+      const middleware = getRpcMethodMiddleware({
+        ...getMinimalOptions(),
+        hostname: 'example.metamask.io',
+      });
+      const request = {
+        jsonrpc,
+        id: 1,
+        method: 'wallet_swap',
+        params: [
+          {
+            from: {
+              // DAI address
+              token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+              amount: '0x10',
+            },
+            to: {
+              chainId: '0x1',
+              // ETH address
+              token_address: '0x0000000000000000000000000000000000000000',
+            },
+          },
+        ],
+      };
+
+      const response = await callMiddleware({ middleware, request });
+      await expect(response?.error?.message).toStrictEqual(
+        'chainId property of from is not defined',
+      );
+    });
+
+    it('should navigate to SwapsAmountView if all conditions are met', async () => {
+      const mockState = {
+        swaps: { '1': { isLive: true }, hasOnboarded: false, isLive: true },
+        fiatOrders: {
+          networks: [
+            {
+              active: true,
+              chainId: 1,
+              chainName: 'Ethereum Mainnet',
+              nativeTokenSupported: true,
+            },
+          ],
+        },
+        engine: {
+          backgroundState: {
+            ...initialBackgroundState,
+            NetworkController: {
+              providerConfig: {
+                type: 'mainnet',
+                chainId: '0',
+                ticker: 'eth',
+              },
+            },
+          },
+        },
+      };
+
+      jest.mock('react-redux', () => ({
+        ...jest.requireActual('react-redux'),
+        useSelector: jest
+          .fn()
+          .mockImplementation((callback) => callback(mockState)),
+      }));
+      const middleware = getRpcMethodMiddleware({
+        ...getMinimalOptions(),
+        hostname: 'example.metamask.io',
+      });
+      const request = {
+        jsonrpc,
+        id: 1,
+        method: 'wallet_swap',
+        params: [
+          {
+            from: {
+              chainId: '0x1',
+              // DAI address
+              token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+              amount: '0x10',
+            },
+            to: {
+              chainId: '0x1',
+              // ETH address
+              token_address: '0x0000000000000000000000000000000000000000',
+            },
+          },
+        ],
+      };
+
+      await callMiddleware({ middleware, request });
+      expect(navigation.navigate).toHaveBeenCalledWith('Swaps', {
+        screen: 'SwapsAmountView',
+        params: {
+          sourceToken: '0x6b175474e89094c44da98b954eedeac495271d0f',
+          destinationToken: '0x0000000000000000000000000000000000000000',
+          amount: '0x10',
+        },
+      });
+    });
+  });
 });
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index a08767c6e5d..d9d720d4239 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -20,7 +20,7 @@ import Networks, {
   getAllNetworks,
 } from '../../util/networks';
 import { isBlockaidFeatureEnabled } from '../../util/blockaid';
-import { polyfillGasPrice } from './utils';
+import { polyfillGasPrice, validateParams } from './utils';
 import ImportedEngine from '../Engine';
 import { strings } from '../../../locales/i18n';
 import { resemblesAddress, safeToChecksumAddress } from '../../util/address';
@@ -39,6 +39,8 @@ import {
   selectProviderType,
 } from '../../selectors/networkController';
 import { regex } from '../../../app/util/regex';
+import { swapsLivenessSelector } from '../../reducers/swaps/index.js';
+import { isSwapsAllowed } from '../../components/UI/Swaps/utils/index.js';
 
 const Engine = ImportedEngine as any;
 
@@ -319,6 +321,51 @@ export const getRpcMethodMiddleware = ({
       permissionRpcMethods.handlers;
 
     const rpcMethods: any = {
+      wallet_swap: async () => {
+        const { from, to } = req.params[0];
+        validateParams(from, ['amount', 'chainId', 'token_address'], 'from');
+        validateParams(to, ['token_address', 'chainId'], 'to');
+
+        const chainId = selectChainId(store.getState());
+
+        if (from.chainId !== to.chainId) {
+          throw ethErrors.rpc.invalidParams(
+            'ChainId value is not consistent between from and to',
+          );
+        }
+
+        if (
+          chainId !== parseInt(from.chainId, 16).toString() ||
+          chainId !== parseInt(to.chainId, 16).toString()
+        ) {
+          // Switch chain id to chain nickname if it exists, if doesn't show the chain id
+          Alert.alert(
+            `This chain is not supported, please switch to this chain id ${parseInt(
+              from.chainId,
+              16,
+            )}`,
+          );
+          return;
+        }
+        // switch to the chain id asked from the dapp
+        // validate if swaps is enable on that network
+        const swapsIsLive = swapsLivenessSelector(store.getState());
+        const isSwappable = isSwapsAllowed(chainId) && swapsIsLive;
+
+        if (!isSwappable) {
+          Alert.alert('Swap is not active or not possible on this chain');
+          return;
+        }
+
+        navigation.navigate('Swaps', {
+          screen: 'SwapsAmountView',
+          params: {
+            sourceToken: from.token_address,
+            destinationToken: to.token_address,
+            amount: from.amount,
+          },
+        });
+      },
       wallet_getPermissions: async () =>
         new Promise<any>((resolve) => {
           getPermissionsHandler.implementation(
diff --git a/app/core/RPCMethods/utils.ts b/app/core/RPCMethods/utils.ts
index bc792d7ddf9..579250b0813 100644
--- a/app/core/RPCMethods/utils.ts
+++ b/app/core/RPCMethods/utils.ts
@@ -1,4 +1,5 @@
 import { query } from '@metamask/controller-utils';
+import { ethErrors } from 'eth-json-rpc-errors';
 import Engine from '../Engine';
 
 export const polyfillGasPrice = async (method: string, params: any[] = []) => {
@@ -12,6 +13,23 @@ export const polyfillGasPrice = async (method: string, params: any[] = []) => {
   return data;
 };
 
+export const validateParams = (
+  obj: any,
+  properties: string[],
+  name: string,
+): void => {
+  if (!obj) {
+    throw ethErrors.rpc.invalidParams(`"${name}" is not defined`);
+  }
+  properties.forEach((property) => {
+    if (!obj[property]) {
+      throw ethErrors.rpc.invalidParams(
+        `${property} property of ${name} is not defined`,
+      );
+    }
+  });
+};
+
 export default {
   polyfillGasPrice,
 };

From f734eea2a3333551e91fdeeeb60ccde298f20d55 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 27 Oct 2023 18:07:33 +0100
Subject: [PATCH 08/29] fix lint

---
 app/core/RPCMethods/RPCMethodMiddleware.test.ts | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index 47f6c356aa5..eb4e69fd246 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1171,6 +1171,7 @@ describe('getRpcMethodMiddleware', () => {
         ],
       };
       const response = await callMiddleware({ middleware, request });
+      //@ts-expect-error now the response can have an error property
       await expect(response?.error?.message).toStrictEqual(
         'ChainId value is not consistent between from and to',
       );
@@ -1202,6 +1203,7 @@ describe('getRpcMethodMiddleware', () => {
       };
 
       const response = await callMiddleware({ middleware, request });
+      //@ts-expect-error now the response can have an error property
       await expect(response?.error?.message).toStrictEqual(
         'chainId property of from is not defined',
       );

From 8e9fa59d79f00b12db4678a33ad23fdd87a7796b Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 27 Oct 2023 18:17:39 +0100
Subject: [PATCH 09/29] add select chain Id

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 1 +
 1 file changed, 1 insertion(+)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 11a69f5d0c2..6d74fd3d105 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -32,6 +32,7 @@ import { getPermittedAccounts } from '../Permissions';
 import AppConstants from '../AppConstants';
 import PPOMUtil from '../../lib/ppom/ppom-util';
 import {
+  selectChainId,
   selectProviderConfig,
   selectProviderType,
 } from '../../selectors/networkController';

From 26f147dd284be509a29259c9e8d45d9a709f2007 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 27 Oct 2023 20:08:41 +0100
Subject: [PATCH 10/29] fix unit test

---
 app/core/RPCMethods/RPCMethodMiddleware.test.ts | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index eb4e69fd246..b10b0a9682f 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1228,20 +1228,17 @@ describe('getRpcMethodMiddleware', () => {
             NetworkController: {
               providerConfig: {
                 type: 'mainnet',
-                chainId: '0',
+                chainId: '1',
                 ticker: 'eth',
               },
             },
           },
         },
       };
+      jest
+        .spyOn(store as Store<Partial<any>, any>, 'getState')
+        .mockImplementation(() => mockState);
 
-      jest.mock('react-redux', () => ({
-        ...jest.requireActual('react-redux'),
-        useSelector: jest
-          .fn()
-          .mockImplementation((callback) => callback(mockState)),
-      }));
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',

From cee58b961863a8b1047422715409e3fdc8669a83 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 10 Nov 2023 23:27:21 +0000
Subject: [PATCH 11/29] update amount to receive wei on hexadecimal format

---
 app/core/RPCMethods/RPCMethodMiddleware.test.ts | 8 ++++----
 app/core/RPCMethods/RPCMethodMiddleware.ts      | 6 +++++-
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index eb57a9a69a4..57758c2c851 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1162,7 +1162,7 @@ describe('getRpcMethodMiddleware', () => {
               chainId: '0x2',
               // DAI address
               token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-              amount: '0x10',
+              amount: '0xDE0B6B3A7640000',
             },
             to: {
               chainId: '0x1',
@@ -1193,7 +1193,7 @@ describe('getRpcMethodMiddleware', () => {
             from: {
               // DAI address
               token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-              amount: '0x10',
+              amount: '0xDE0B6B3A7640000',
             },
             to: {
               chainId: '0x1',
@@ -1255,7 +1255,7 @@ describe('getRpcMethodMiddleware', () => {
               chainId: '0x1',
               // DAI address
               token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-              amount: '0x10',
+              amount: '0xDE0B6B3A7640000',
             },
             to: {
               chainId: '0x1',
@@ -1272,7 +1272,7 @@ describe('getRpcMethodMiddleware', () => {
         params: {
           sourceToken: '0x6b175474e89094c44da98b954eedeac495271d0f',
           destinationToken: '0x0000000000000000000000000000000000000000',
-          amount: '0x10',
+          amount: '1',
         },
       });
     });
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 68215853a25..3044d3f9a44 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -39,6 +39,7 @@ import {
 import { regex } from '../../../app/util/regex';
 import { swapsLivenessSelector } from '../../reducers/swaps/index.js';
 import { isSwapsAllowed } from '../../components/UI/Swaps/utils/index.js';
+import { fromWei } from '../../util/number/index.js';
 
 const Engine = ImportedEngine as any;
 
@@ -356,12 +357,15 @@ export const getRpcMethodMiddleware = ({
           return;
         }
 
+        const decimalWei = parseInt(from.amount, 16);
+        const tokenAmount = fromWei(decimalWei);
+
         navigation.navigate('Swaps', {
           screen: 'SwapsAmountView',
           params: {
             sourceToken: from.token_address,
             destinationToken: to.token_address,
-            amount: from.amount,
+            amount: tokenAmount,
           },
         });
       },

From cbca9f95ede0764dd0e355f11b9e20aa83e30951 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Sat, 11 Nov 2023 00:13:36 +0000
Subject: [PATCH 12/29] change message when the dapp asks for a chain id on the
 swap and the user have another chain selected

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 3044d3f9a44..0560e344de9 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -340,7 +340,7 @@ export const getRpcMethodMiddleware = ({
         ) {
           // Switch chain id to chain nickname if it exists, if doesn't show the chain id
           Alert.alert(
-            `This chain is not supported, please switch to this chain id ${parseInt(
+            `This chain is not selected, please switch to this chain id ${parseInt(
               from.chainId,
               16,
             )}`,

From 3f15d44a92a900ab7ee2753b50dd6bdd3928e1fc Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Tue, 5 Dec 2023 00:07:24 +0000
Subject: [PATCH 13/29] change old util to new util of ramp and new route to
 buy ramp

---
 app/components/Views/SendFlow/Amount/index.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/app/components/Views/SendFlow/Amount/index.js b/app/components/Views/SendFlow/Amount/index.js
index 84779c9a386..942f56b04ae 100644
--- a/app/components/Views/SendFlow/Amount/index.js
+++ b/app/components/Views/SendFlow/Amount/index.js
@@ -99,13 +99,13 @@ import { selectContractBalances } from '../../../../selectors/tokenBalancesContr
 import { selectSelectedAddress } from '../../../../selectors/preferencesController';
 import { PREFIX_HEX_STRING } from '../../../../constants/transaction';
 import Routes from '../../../../constants/navigation/Routes';
-import { isNetworkBuyNativeTokenSupported } from '../../../UI/Ramp/utils';
 import { getRampNetworks } from '../../../../reducers/fiatOrders';
 import { swapsLivenessSelector } from '../../../../reducers/swaps';
 import { isSwapsAllowed } from '../../../../components/UI/Swaps/utils';
 import { swapsUtils } from '@metamask/swaps-controller';
 import { regex } from '../../../../util/regex';
 import { AmountViewSelectorsIDs } from '../../../../../e2e/selectors/SendFlow/AmountView.selectors';
+import { isNetworkRampNativeTokenSupported } from '../../../UI/Ramp/common/utils';
 
 const KEYBOARD_OFFSET = Device.isSmallDevice() ? 80 : 120;
 
@@ -1270,7 +1270,7 @@ class Amount extends PureComponent {
           location: 'insufficient_funds_warning',
           text: 'buy_more',
         });
-        navigation.navigate(Routes.FIAT_ON_RAMP_AGGREGATOR.ID);
+        navigation.navigate(Routes.RAMP.BUY);
       }
     };
 
@@ -1520,7 +1520,7 @@ const mapStateToProps = (state, ownProps) => ({
   transactionState: ownProps.transaction || state.transaction,
   selectedAsset: state.transaction.selectedAsset,
   isPaymentRequest: state.transaction.paymentRequest,
-  isNetworkBuyNativeTokenSupported: isNetworkBuyNativeTokenSupported(
+  isNetworkBuyNativeTokenSupported: isNetworkRampNativeTokenSupported(
     selectChainId(state),
     getRampNetworks(state),
   ),

From e7791a3c19222e264e1315e1a30ff3d450415d60 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 21 Dec 2023 01:20:10 +0000
Subject: [PATCH 14/29] taking into account the address connected to the dapp,
 if it is the dapp connected address different from the one in the wallet we
 change before we navigate to the swaps view

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 30 +++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 224c134d8d3..73bbafacedc 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -36,6 +36,10 @@ import {
   selectProviderConfig,
   selectProviderType,
 } from '../../selectors/networkController';
+import {
+  selectIdentities,
+  selectSelectedAddress,
+} from '../../selectors/preferencesController';
 import { setEventStageError, setEventStage } from '../../actions/rpcEvents';
 import { isWhitelistedRPC, RPCStageTypes } from '../../reducers/rpcEvents';
 import { regex } from '../../../app/util/regex';
@@ -330,7 +334,19 @@ export const getRpcMethodMiddleware = ({
 
     const rpcMethods: any = {
       wallet_swap: async () => {
-        const { from, to } = req.params[0];
+        const { from, to, user_address } = req.params[0];
+        const identities = selectIdentities(store.getState());
+        const selectedAddress = selectSelectedAddress(store.getState());
+        const dappConnectedAccount = Object.keys(identities).find(
+          (address) =>
+            safeToChecksumAddress(address) ===
+            safeToChecksumAddress(user_address),
+        );
+
+        if (!dappConnectedAccount) {
+          throw ethErrors.rpc.invalidParams('This address does not exist');
+        }
+
         validateParams(from, ['amount', 'chainId', 'token_address'], 'from');
         validateParams(to, ['token_address', 'chainId'], 'to');
 
@@ -342,6 +358,18 @@ export const getRpcMethodMiddleware = ({
           );
         }
 
+        const checksummedDappConnectedAccount =
+          safeToChecksumAddress(dappConnectedAccount);
+
+        if (
+          safeToChecksumAddress(selectedAddress) !==
+          checksummedDappConnectedAccount
+        ) {
+          Engine.context.PreferencesController.setSelectedAddress(
+            checksummedDappConnectedAccount,
+          );
+        }
+
         if (
           chainId !== parseInt(from.chainId, 16).toString() ||
           chainId !== parseInt(to.chainId, 16).toString()

From 2489a1696842cdf9e474d9fa5083c5546360e7f0 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 21 Dec 2023 02:54:17 +0000
Subject: [PATCH 15/29] added logic for future support of multiple swap tokens
 and cross chain swaps

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 73bbafacedc..f4d7ffda17a 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -347,12 +347,20 @@ export const getRpcMethodMiddleware = ({
           throw ethErrors.rpc.invalidParams('This address does not exist');
         }
 
-        validateParams(from, ['amount', 'chainId', 'token_address'], 'from');
+        // This condition is only needed until we support multiple source tokens swap
+        if (from.length > 1) {
+          throw ethErrors.rpc.invalidParams(
+            'Currently we de not support multiple tokens swap',
+          );
+        }
+
+        validateParams(from[0], ['amount', 'chainId', 'token_address'], 'from');
         validateParams(to, ['token_address', 'chainId'], 'to');
 
         const chainId = selectChainId(store.getState());
 
-        if (from.chainId !== to.chainId) {
+        //  This verification is not needed when we support cross chain swaps
+        if (from[0].chainId !== to.chainId) {
           throw ethErrors.rpc.invalidParams(
             'ChainId value is not consistent between from and to',
           );
@@ -370,14 +378,15 @@ export const getRpcMethodMiddleware = ({
           );
         }
 
+        // This condition will only lives until we can do cross chain swaps
         if (
-          chainId !== parseInt(from.chainId, 16).toString() ||
+          chainId !== parseInt(from[0].chainId, 16).toString() ||
           chainId !== parseInt(to.chainId, 16).toString()
         ) {
           // Switch chain id to chain nickname if it exists, if doesn't show the chain id
           Alert.alert(
             `This chain is not selected, please switch to this chain id ${parseInt(
-              from.chainId,
+              from[0].chainId,
               16,
             )}`,
           );
@@ -393,13 +402,13 @@ export const getRpcMethodMiddleware = ({
           return;
         }
 
-        const decimalWei = parseInt(from.amount, 16);
+        const decimalWei = parseInt(from[0].amount, 16);
         const tokenAmount = fromWei(decimalWei);
 
         navigation.navigate('Swaps', {
           screen: 'SwapsAmountView',
           params: {
-            sourceToken: from.token_address,
+            sourceToken: from[0].token_address,
             destinationToken: to.token_address,
             amount: tokenAmount,
           },

From 3acba7586e1380452dd7f438be9eac3a0df5a210 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 21 Dec 2023 13:00:56 +0000
Subject: [PATCH 16/29] change name of json rpc method to wallet_swapAsset

---
 app/core/RPCMethods/RPCMethodMiddleware.test.ts | 8 ++++----
 app/core/RPCMethods/RPCMethodMiddleware.ts      | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index 730016080b5..ca4a8dfe21f 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1154,7 +1154,7 @@ describe('getRpcMethodMiddleware', () => {
       expect(spy).toBeCalledTimes(1);
     });
   });
-  describe('wallet_swap', () => {
+  describe('wallet_swapAsset', () => {
     it('should throw error if chainId is not consistent between from and to', async () => {
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
@@ -1163,7 +1163,7 @@ describe('getRpcMethodMiddleware', () => {
       const request = {
         jsonrpc,
         id: 1,
-        method: 'wallet_swap',
+        method: 'wallet_swapAsset',
         params: [
           {
             from: {
@@ -1195,7 +1195,7 @@ describe('getRpcMethodMiddleware', () => {
       const request = {
         jsonrpc,
         id: 1,
-        method: 'wallet_swap',
+        method: 'wallet_swapAsset',
         params: [
           {
             from: {
@@ -1256,7 +1256,7 @@ describe('getRpcMethodMiddleware', () => {
       const request = {
         jsonrpc,
         id: 1,
-        method: 'wallet_swap',
+        method: 'wallet_swapAsset',
         params: [
           {
             from: {
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index f4d7ffda17a..598cf230673 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -333,7 +333,7 @@ export const getRpcMethodMiddleware = ({
       permissionRpcMethods.handlers;
 
     const rpcMethods: any = {
-      wallet_swap: async () => {
+      wallet_swapAsset: async () => {
         const { from, to, user_address } = req.params[0];
         const identities = selectIdentities(store.getState());
         const selectedAddress = selectSelectedAddress(store.getState());

From e457aac88b1aa11f286386bb19b8622210708337 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 21 Dec 2023 16:17:11 +0000
Subject: [PATCH 17/29] update tests. ask if the user wants to switch network
 when the chain id used on the swap rpc params is different from what is being
 used on the wallet

---
 .../RPCMethods/RPCMethodMiddleware.test.ts    | 127 +++++++++++++++---
 app/core/RPCMethods/RPCMethodMiddleware.ts    |  20 +--
 2 files changed, 120 insertions(+), 27 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index ca4a8dfe21f..f33ae235bfc 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1156,6 +1156,43 @@ describe('getRpcMethodMiddleware', () => {
   });
   describe('wallet_swapAsset', () => {
     it('should throw error if chainId is not consistent between from and to', async () => {
+      const mockState = {
+        swaps: { '1': { isLive: true }, hasOnboarded: false, isLive: true },
+        fiatOrders: {
+          networks: [
+            {
+              active: true,
+              chainId: 1,
+              chainName: 'Ethereum Mainnet',
+              nativeTokenSupported: true,
+            },
+          ],
+        },
+        engine: {
+          backgroundState: {
+            ...initialBackgroundState,
+            PreferencesController: {
+              selectedAddress: '0x0',
+              identities: {
+                '0x0': {
+                  address: '0x0',
+                  name: 'Account 1',
+                },
+              },
+            },
+            NetworkController: {
+              providerConfig: {
+                type: 'mainnet',
+                chainId: '1',
+                ticker: 'eth',
+              },
+            },
+          },
+        },
+      };
+      jest
+        .spyOn(store as Store<Partial<any>, any>, 'getState')
+        .mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1166,17 +1203,20 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: {
-              chainId: '0x2',
-              // DAI address
-              token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-              amount: '0xDE0B6B3A7640000',
-            },
+            from: [
+              {
+                chainId: '0x2',
+                // DAI address
+                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                amount: '0xDE0B6B3A7640000',
+              },
+            ],
             to: {
               chainId: '0x1',
               // ETH address
               token_address: '0x0000000000000000000000000000000000000000',
             },
+            user_address: '0x0',
           },
         ],
       };
@@ -1188,6 +1228,43 @@ describe('getRpcMethodMiddleware', () => {
     });
 
     it('should throw error if chainId, from property does not have chainId property', async () => {
+      const mockState = {
+        swaps: { '1': { isLive: true }, hasOnboarded: false, isLive: true },
+        fiatOrders: {
+          networks: [
+            {
+              active: true,
+              chainId: 1,
+              chainName: 'Ethereum Mainnet',
+              nativeTokenSupported: true,
+            },
+          ],
+        },
+        engine: {
+          backgroundState: {
+            ...initialBackgroundState,
+            PreferencesController: {
+              selectedAddress: '0x0',
+              identities: {
+                '0x0': {
+                  address: '0x0',
+                  name: 'Account 1',
+                },
+              },
+            },
+            NetworkController: {
+              providerConfig: {
+                type: 'mainnet',
+                chainId: '1',
+                ticker: 'eth',
+              },
+            },
+          },
+        },
+      };
+      jest
+        .spyOn(store as Store<Partial<any>, any>, 'getState')
+        .mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1198,16 +1275,19 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: {
-              // DAI address
-              token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-              amount: '0xDE0B6B3A7640000',
-            },
+            from: [
+              {
+                // DAI address
+                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                amount: '0xDE0B6B3A7640000',
+              },
+            ],
             to: {
               chainId: '0x1',
               // ETH address
               token_address: '0x0000000000000000000000000000000000000000',
             },
+            user_address: '0x0',
           },
         ],
       };
@@ -1235,6 +1315,15 @@ describe('getRpcMethodMiddleware', () => {
         engine: {
           backgroundState: {
             ...initialBackgroundState,
+            PreferencesController: {
+              selectedAddress: '0x0',
+              identities: {
+                '0x0': {
+                  address: '0x0',
+                  name: 'Account 1',
+                },
+              },
+            },
             NetworkController: {
               providerConfig: {
                 type: 'mainnet',
@@ -1248,7 +1337,6 @@ describe('getRpcMethodMiddleware', () => {
       jest
         .spyOn(store as Store<Partial<any>, any>, 'getState')
         .mockImplementation(() => mockState);
-
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1259,17 +1347,20 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: {
-              chainId: '0x1',
-              // DAI address
-              token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-              amount: '0xDE0B6B3A7640000',
-            },
+            from: [
+              {
+                chainId: '0x1',
+                // DAI address
+                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                amount: '0xDE0B6B3A7640000',
+              },
+            ],
             to: {
               chainId: '0x1',
               // ETH address
               token_address: '0x0000000000000000000000000000000000000000',
             },
+            user_address: '0x0',
           },
         ],
       };
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 598cf230673..470c18ffb2e 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -378,19 +378,21 @@ export const getRpcMethodMiddleware = ({
           );
         }
 
-        // This condition will only lives until we can do cross chain swaps
         if (
           chainId !== parseInt(from[0].chainId, 16).toString() ||
           chainId !== parseInt(to.chainId, 16).toString()
         ) {
-          // Switch chain id to chain nickname if it exists, if doesn't show the chain id
-          Alert.alert(
-            `This chain is not selected, please switch to this chain id ${parseInt(
-              from[0].chainId,
-              16,
-            )}`,
-          );
-          return;
+          await RPCMethods.wallet_switchEthereumChain({
+            req: {
+              params: [{ chainId: from[0].chainId }],
+            },
+            res,
+            requestUserApproval,
+            analytics: {
+              request_source: getSource(),
+              request_platform: analytics?.platform,
+            },
+          });
         }
         // switch to the chain id asked from the dapp
         // validate if swaps is enable on that network

From 36ddc1da42b7f1bb79578535567753ec02d0e1f3 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 21 Dec 2023 23:52:43 +0000
Subject: [PATCH 18/29] update snapshot

---
 .../SendFlow/Amount/__snapshots__/index.test.tsx.snap | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap b/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap
index a30cddc7d58..3a1117e9550 100644
--- a/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap
+++ b/app/components/Views/SendFlow/Amount/__snapshots__/index.test.tsx.snap
@@ -614,6 +614,7 @@ exports[`Amount should convert ERC-20 token value to USD 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -1331,6 +1332,7 @@ exports[`Amount should convert ETH to USD 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -2065,6 +2067,7 @@ exports[`Amount should convert USD to ERC-20 token value 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -2799,6 +2802,7 @@ exports[`Amount should convert USD to ETH 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -3515,6 +3519,7 @@ exports[`Amount should display correct balance 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -4231,6 +4236,7 @@ exports[`Amount should not show a warning when conversion rate is available 1`]
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -4932,6 +4938,7 @@ exports[`Amount should not show a warning when transfering collectibles 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -5649,6 +5656,7 @@ exports[`Amount should proceed if balance is sufficient while on Native primary
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={0.2}
                             disabled={false}
                             onPress={[Function]}
@@ -6355,6 +6363,7 @@ exports[`Amount should render correctly 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -7066,6 +7075,7 @@ exports[`Amount should show a warning when conversion rate is not available 1`]
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={1}
                             disabled={true}
                             style={
@@ -7824,6 +7834,7 @@ exports[`Amount should show an error message if balance is insufficient 1`] = `
                         >
                           <TouchableOpacity
                             accessibilityRole="button"
+                            accessible={true}
                             activeOpacity={0.2}
                             disabled={false}
                             onPress={[Function]}

From 5d347cf6d697170906da0dbade867445ebffbbc3 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Thu, 25 Apr 2024 19:43:14 +0100
Subject: [PATCH 19/29] remove chain id verifications

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 27 ++--------------------
 1 file changed, 2 insertions(+), 25 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 8917e01a8fc..2357fe61449 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -391,18 +391,11 @@ export const getRpcMethodMiddleware = ({
           );
         }
 
-        validateParams(from[0], ['amount', 'chainId', 'token_address'], 'from');
-        validateParams(to, ['token_address', 'chainId'], 'to');
+        validateParams(from[0], ['amount', 'token_address'], 'from');
+        validateParams(to, ['token_address'], 'to');
 
         const chainId = selectChainId(store.getState());
 
-        //  This verification is not needed when we support cross chain swaps
-        if (from[0].chainId !== to.chainId) {
-          throw ethErrors.rpc.invalidParams(
-            'ChainId value is not consistent between from and to',
-          );
-        }
-
         const checksummedDappConnectedAccount =
           safeToChecksumAddress(dappConnectedAccount);
 
@@ -415,22 +408,6 @@ export const getRpcMethodMiddleware = ({
           );
         }
 
-        if (
-          chainId !== parseInt(from[0].chainId, 16).toString() ||
-          chainId !== parseInt(to.chainId, 16).toString()
-        ) {
-          await RPCMethods.wallet_switchEthereumChain({
-            req: {
-              params: [{ chainId: from[0].chainId }],
-            },
-            res,
-            requestUserApproval,
-            analytics: {
-              request_source: getSource(),
-              request_platform: analytics?.platform,
-            },
-          });
-        }
         // switch to the chain id asked from the dapp
         // validate if swaps is enable on that network
         const swapsIsLive = swapsLivenessSelector(store.getState());

From 6f675ad1110107894271f2e16f5b5ae98e6ee187 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Fri, 17 May 2024 21:06:36 +0100
Subject: [PATCH 20/29] added methodNotSupported error if there is a try of
 multi tokens swaps, changed amount to value and added default to 0 if value
 is not defined

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 10 +++++-----
 app/core/RPCMethods/utils.ts               |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index ebcd4637759..a332f5f7bce 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -383,17 +383,17 @@ export const getRpcMethodMiddleware = ({
         );
 
         if (!dappConnectedAccount) {
-          throw ethErrors.rpc.invalidParams('This address does not exist');
+          throw rpcErrors.invalidParams('This address does not exist');
         }
 
         // This condition is only needed until we support multiple source tokens swap
         if (from.length > 1) {
-          throw ethErrors.rpc.invalidParams(
+          throw rpcErrors.methodNotSupported(
             'Currently we de not support multiple tokens swap',
           );
         }
 
-        validateParams(from[0], ['amount', 'token_address'], 'from');
+        validateParams(from[0], ['token_address'], 'from');
         validateParams(to, ['token_address'], 'to');
 
         const chainId = selectChainId(store.getState());
@@ -419,8 +419,8 @@ export const getRpcMethodMiddleware = ({
           Alert.alert('Swap is not active or not possible on this chain');
           return;
         }
-
-        const decimalWei = parseInt(from[0].amount, 16);
+        //If value is not defined by the dapp it defaults to 0
+        const decimalWei = parseInt(from[0].value ?? 0, 16);
         const tokenAmount = fromWei(decimalWei);
 
         navigation.navigate('Swaps', {
diff --git a/app/core/RPCMethods/utils.ts b/app/core/RPCMethods/utils.ts
index f2ea4703eab..68b40865936 100644
--- a/app/core/RPCMethods/utils.ts
+++ b/app/core/RPCMethods/utils.ts
@@ -1,5 +1,5 @@
 import { query } from '@metamask/controller-utils';
-import { ethErrors } from 'eth-json-rpc-errors';
+import { rpcErrors } from '@metamask/rpc-errors';
 import Engine from '../Engine';
 
 export const polyfillGasPrice = async (method: string, params: any[] = []) => {
@@ -22,11 +22,11 @@ export const validateParams = (
   name: string,
 ): void => {
   if (!obj) {
-    throw ethErrors.rpc.invalidParams(`"${name}" is not defined`);
+    throw rpcErrors.invalidParams(`"${name}" is not defined`);
   }
   properties.forEach((property) => {
     if (!obj[property]) {
-      throw ethErrors.rpc.invalidParams(
+      throw rpcErrors.invalidParams(
         `${property} property of ${name} is not defined`,
       );
     }

From d88b883d62871773bc12bf9a3801653e7def7122 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 20 May 2024 15:04:21 +0100
Subject: [PATCH 21/29] enable wallet swap asset and navigate to the import
 sheet when the token is not on the token list

---
 .../UI/Swaps/components/TokenSelectModal.js   | 22 +++++++++++++++++--
 app/components/UI/Swaps/index.js              | 21 +++++++++++++-----
 app/core/Permissions/specifications.js        |  1 +
 app/core/RPCMethods/RPCMethodMiddleware.ts    |  7 +++++-
 4 files changed, 43 insertions(+), 8 deletions(-)

diff --git a/app/components/UI/Swaps/components/TokenSelectModal.js b/app/components/UI/Swaps/components/TokenSelectModal.js
index 0236d5a44ec..37343e17ac3 100644
--- a/app/components/UI/Swaps/components/TokenSelectModal.js
+++ b/app/components/UI/Swaps/components/TokenSelectModal.js
@@ -1,4 +1,10 @@
-import React, { useCallback, useMemo, useRef, useState } from 'react';
+import React, {
+  useCallback,
+  useEffect,
+  useMemo,
+  useRef,
+  useState,
+} from 'react';
 import PropTypes from 'prop-types';
 import {
   StyleSheet,
@@ -155,6 +161,7 @@ function TokenSelectModal({
   providerConfig,
   networkConfigurations,
   balances,
+  initialSearchString = '',
 }) {
   const navigation = useNavigation();
   const { trackAnonymousEvent } = useMetrics();
@@ -301,6 +308,14 @@ function TokenSelectModal({
     showTokenImportModal();
   }, [showTokenImportModal]);
 
+  useEffect(() => {
+    !!initialSearchString && setSearchString(initialSearchString);
+
+    if (tokenMetadata.valid) {
+      handleShowImportToken();
+    }
+  }, [initialSearchString, handleShowImportToken, tokenMetadata.valid]);
+
   const handlePressImportToken = useCallback(
     (item) => {
       const { address, symbol } = item;
@@ -384,7 +399,6 @@ function TokenSelectModal({
     setSearchString('');
     searchInput?.current?.focus();
   }, [setSearchString]);
-
   return (
     <Modal
       isVisible={isVisible}
@@ -564,6 +578,10 @@ TokenSelectModal.propTypes = {
    * Network configurations
    */
   networkConfigurations: PropTypes.object,
+  /**
+   * Initial search string with token address
+   * */
+  initialSearchString: PropTypes.string,
 };
 
 const mapStateToProps = (state) => ({
diff --git a/app/components/UI/Swaps/index.js b/app/components/UI/Swaps/index.js
index f7758d94d5e..b220eaff003 100644
--- a/app/components/UI/Swaps/index.js
+++ b/app/components/UI/Swaps/index.js
@@ -238,6 +238,7 @@ function SwapsAmountView({
       toLowerCaseEquals(token.address, initialDestination),
     ),
   );
+  const [initialDestinationSearch, setInitialDestinationSearch] = useState('');
   const [hasDismissedTokenAlert, setHasDismissedTokenAlert] = useState(true);
   const [contractBalance, setContractBalance] = useState(null);
   const [contractBalanceAsUnits, setContractBalanceAsUnits] = useState(
@@ -371,13 +372,22 @@ function SwapsAmountView({
   useEffect(() => {
     if (canSetAnInitialTokenDestination) {
       setIsDestinationSet(true);
-      setDestinationToken(
-        swapsTokens.find((token) =>
-          toLowerCaseEquals(token.address, initialDestination),
-        ),
+      const destinationTokenOnList = swapsTokens.find((token) =>
+        toLowerCaseEquals(token.address, initialDestination),
       );
+      if (destinationTokenOnList) {
+        setDestinationToken(destinationTokenOnList);
+      } else {
+        toggleDestinationModal();
+        setInitialDestinationSearch(initialDestination);
+      }
     }
-  }, [canSetAnInitialTokenDestination, initialDestination, swapsTokens]);
+  }, [
+    canSetAnInitialTokenDestination,
+    initialDestination,
+    swapsTokens,
+    toggleDestinationModal,
+  ]);
 
   const canSetInitialAmount =
     destinationToken && sourceToken && initialAmount && swapsControllerTokens;
@@ -791,6 +801,7 @@ function SwapsAmountView({
             ]}
             onItemPress={handleDestinationTokenPress}
             excludeAddresses={[sourceToken?.address]}
+            initialSearchString={initialDestinationSearch}
           />
         </View>
         <View>
diff --git a/app/core/Permissions/specifications.js b/app/core/Permissions/specifications.js
index 3ba0ebd2060..75253994a6f 100644
--- a/app/core/Permissions/specifications.js
+++ b/app/core/Permissions/specifications.js
@@ -306,4 +306,5 @@ export const unrestrictedMethods = Object.freeze([
   'metamask_logWeb3ShimUsage',
   'wallet_switchEthereumChain',
   'wallet_addEthereumChain',
+  'wallet_swapAsset',
 ]);
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index a332f5f7bce..d1efdeb2712 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -21,6 +21,7 @@ import {
 import Networks, {
   blockTagParamIndex,
   getAllNetworks,
+  getNetworkNameFromProviderConfig,
 } from '../../util/networks';
 import { polyfillGasPrice, validateParams } from './utils';
 import ImportedEngine from '../Engine';
@@ -416,7 +417,11 @@ export const getRpcMethodMiddleware = ({
         const isSwappable = isSwapsAllowed(chainId) && swapsIsLive;
 
         if (!isSwappable) {
-          Alert.alert('Swap is not active or not possible on this chain');
+          const providerConfig = selectProviderConfig(store.getState());
+
+          const networkName = getNetworkNameFromProviderConfig(providerConfig);
+
+          Alert.alert(`Swap is not available on this chain ${networkName}`);
           return;
         }
         //If value is not defined by the dapp it defaults to 0

From d3a369c3d7de123668d7963f75c112391502eea5 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 20 May 2024 18:56:13 +0100
Subject: [PATCH 22/29] add unit tests for each error scenario

---
 .../RPCMethods/RPCMethodMiddleware.test.ts    | 176 ++++++++++++++++--
 app/core/RPCMethods/RPCMethodMiddleware.ts    |   4 +-
 2 files changed, 165 insertions(+), 15 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index a53467676ec..1abfe81a472 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1328,9 +1328,81 @@ describe('getRpcMethodMiddleware', () => {
     });
   });
   describe('wallet_swapAsset', () => {
-    it('should throw error if chainId is not consistent between from and to', async () => {
+    it('should throw error if the account sent by the dapp is not the one connected', async () => {
       const mockState = {
-        swaps: { '1': { isLive: true }, hasOnboarded: false, isLive: true },
+        swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
+        fiatOrders: {
+          networks: [
+            {
+              active: true,
+              chainId: 1,
+              chainName: 'Ethereum Mainnet',
+              nativeTokenSupported: true,
+            },
+          ],
+        },
+        engine: {
+          backgroundState: {
+            ...initialBackgroundState,
+            PreferencesController: {
+              selectedAddress: '0x1',
+              identities: {
+                '0x1': {
+                  address: '0x1',
+                  name: 'Account 1',
+                },
+              },
+            },
+            NetworkController: {
+              providerConfig: {
+                type: 'mainnet',
+                chainId: '0x1',
+                ticker: 'eth',
+              },
+            },
+          },
+        },
+      };
+      jest
+        .spyOn(store as Store<Partial<any>, any>, 'getState')
+        .mockImplementation(() => mockState);
+      const middleware = getRpcMethodMiddleware({
+        ...getMinimalOptions(),
+        hostname: 'example.metamask.io',
+      });
+      const request = {
+        jsonrpc,
+        id: 1,
+        method: 'wallet_swapAsset',
+        params: [
+          {
+            from: [
+              {
+                // DAI address
+                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                value: '0xDE0B6B3A7640000',
+              },
+            ],
+            to: {
+              chainId: '0x1',
+              // ETH address
+              token_address: '0x0000000000000000000000000000000000000000',
+            },
+            user_address: '0x0',
+          },
+        ],
+      };
+
+      const response = await callMiddleware({ middleware, request });
+      //@ts-expect-error now the response can have an error property
+      await expect(response?.error?.message).toStrictEqual(
+        'This address does not exist',
+      );
+    });
+
+    it('should throw error if it was sent more than one token to swap from', async () => {
+      const mockState = {
+        swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
           networks: [
             {
@@ -1356,7 +1428,7 @@ describe('getRpcMethodMiddleware', () => {
             NetworkController: {
               providerConfig: {
                 type: 'mainnet',
-                chainId: '1',
+                chainId: '0x1',
                 ticker: 'eth',
               },
             },
@@ -1378,10 +1450,85 @@ describe('getRpcMethodMiddleware', () => {
           {
             from: [
               {
-                chainId: '0x2',
                 // DAI address
                 token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-                amount: '0xDE0B6B3A7640000',
+                value: '0xDE0B6B3A7640000',
+              },
+              {
+                // ETH address
+                token_address: '0x0000000000000000000000000000000000000000',
+                value: '0xDE0B6B3A7640000',
+              },
+            ],
+            to: {
+              chainId: '0x1',
+              // ETH address
+              token_address: '0x0000000000000000000000000000000000000000',
+            },
+            user_address: '0x0',
+          },
+        ],
+      };
+
+      const response = await callMiddleware({ middleware, request });
+      //@ts-expect-error now the response can have an error property
+      await expect(response?.error?.message).toStrictEqual(
+        'Currently we de not support multiple tokens swap',
+      );
+    });
+
+    it('should throw error if token_address required param is not defined', async () => {
+      const mockState = {
+        swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
+        fiatOrders: {
+          networks: [
+            {
+              active: true,
+              chainId: 1,
+              chainName: 'Ethereum Mainnet',
+              nativeTokenSupported: true,
+            },
+          ],
+        },
+        engine: {
+          backgroundState: {
+            ...initialBackgroundState,
+            PreferencesController: {
+              selectedAddress: '0x0',
+              identities: {
+                '0x0': {
+                  address: '0x0',
+                  name: 'Account 1',
+                },
+              },
+            },
+            NetworkController: {
+              providerConfig: {
+                type: 'mainnet',
+                chainId: '0x1',
+                ticker: 'eth',
+              },
+            },
+          },
+        },
+      };
+      jest
+        .spyOn(store as Store<Partial<any>, any>, 'getState')
+        .mockImplementation(() => mockState);
+      const middleware = getRpcMethodMiddleware({
+        ...getMinimalOptions(),
+        hostname: 'example.metamask.io',
+      });
+      const request = {
+        jsonrpc,
+        id: 1,
+        method: 'wallet_swapAsset',
+        params: [
+          {
+            from: [
+              {
+                // DAI address
+                value: '0xDE0B6B3A7640000',
               },
             ],
             to: {
@@ -1393,16 +1540,17 @@ describe('getRpcMethodMiddleware', () => {
           },
         ],
       };
+
       const response = await callMiddleware({ middleware, request });
       //@ts-expect-error now the response can have an error property
       await expect(response?.error?.message).toStrictEqual(
-        'ChainId value is not consistent between from and to',
+        'token_address property of from is not defined',
       );
     });
 
-    it('should throw error if chainId, from property does not have chainId property', async () => {
+    it('should throw error if swap is not live', async () => {
       const mockState = {
-        swaps: { '1': { isLive: true }, hasOnboarded: false, isLive: true },
+        swaps: { '0x1': { isLive: false }, hasOnboarded: false, isLive: false },
         fiatOrders: {
           networks: [
             {
@@ -1428,7 +1576,7 @@ describe('getRpcMethodMiddleware', () => {
             NetworkController: {
               providerConfig: {
                 type: 'mainnet',
-                chainId: '1',
+                chainId: '0x1',
                 ticker: 'eth',
               },
             },
@@ -1452,7 +1600,7 @@ describe('getRpcMethodMiddleware', () => {
               {
                 // DAI address
                 token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-                amount: '0xDE0B6B3A7640000',
+                value: '0xDE0B6B3A7640000',
               },
             ],
             to: {
@@ -1468,13 +1616,13 @@ describe('getRpcMethodMiddleware', () => {
       const response = await callMiddleware({ middleware, request });
       //@ts-expect-error now the response can have an error property
       await expect(response?.error?.message).toStrictEqual(
-        'chainId property of from is not defined',
+        'Swap is not available on this chain Ethereum Main Network',
       );
     });
 
     it('should navigate to SwapsAmountView if all conditions are met', async () => {
       const mockState = {
-        swaps: { '1': { isLive: true }, hasOnboarded: false, isLive: true },
+        swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
           networks: [
             {
@@ -1500,7 +1648,7 @@ describe('getRpcMethodMiddleware', () => {
             NetworkController: {
               providerConfig: {
                 type: 'mainnet',
-                chainId: '1',
+                chainId: '0x1',
                 ticker: 'eth',
               },
             },
@@ -1525,7 +1673,7 @@ describe('getRpcMethodMiddleware', () => {
                 chainId: '0x1',
                 // DAI address
                 token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
-                amount: '0xDE0B6B3A7640000',
+                value: '0xDE0B6B3A7640000',
               },
             ],
             to: {
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index d1efdeb2712..384e077b0d3 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -422,7 +422,9 @@ export const getRpcMethodMiddleware = ({
           const networkName = getNetworkNameFromProviderConfig(providerConfig);
 
           Alert.alert(`Swap is not available on this chain ${networkName}`);
-          return;
+          throw rpcErrors.methodNotSupported(
+            `Swap is not available on this chain ${networkName}`,
+          );
         }
         //If value is not defined by the dapp it defaults to 0
         const decimalWei = parseInt(from[0].value ?? 0, 16);

From f7cee6e90ff8b4707bb50a616bfbc03c0e709805 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 24 Jun 2024 12:40:48 +0100
Subject: [PATCH 23/29] added caip 10 addresses support

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 75 ++++++++++++++------
 app/core/RPCMethods/utils.ts               |  3 +-
 app/util/caip10Address/index.test.ts       | 80 ++++++++++++++++++++++
 app/util/caip10Address/index.ts            | 47 +++++++++++++
 4 files changed, 182 insertions(+), 23 deletions(-)
 create mode 100644 app/util/caip10Address/index.test.ts
 create mode 100644 app/util/caip10Address/index.ts

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 560d9592c84..560f32c9b0c 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -36,10 +36,7 @@ import {
   selectProviderConfig,
   selectProviderType,
 } from '../../selectors/networkController';
-import {
-  selectIdentities,
-  selectSelectedAddress,
-} from '../../selectors/preferencesController';
+import { selectIdentities } from '../../selectors/preferencesController';
 import { setEventStageError, setEventStage } from '../../actions/rpcEvents';
 import { isWhitelistedRPC, RPCStageTypes } from '../../reducers/rpcEvents';
 import { regex } from '../../../app/util/regex';
@@ -49,6 +46,8 @@ import { fromWei } from '../../util/number/index.js';
 import Logger from '../../../app/util/Logger';
 import DevLogger from '../SDKConnect/utils/DevLogger';
 import { addTransaction } from '../../util/transaction-controller';
+import { selectSelectedInternalAccountChecksummedAddress } from '../../selectors/accountsController';
+import { parseCaip10Address } from '../../util/caip10Address';
 
 // TODO: Replace "any" with type
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -393,13 +392,21 @@ export const getRpcMethodMiddleware = ({
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const rpcMethods: any = {
       wallet_swapAsset: async () => {
-        const { from, to, user_address } = req.params[0];
+        const { fromToken, toToken, user_address } = req.params[0];
         const identities = selectIdentities(store.getState());
-        const selectedAddress = selectSelectedAddress(store.getState());
+        const selectedAddress = selectSelectedInternalAccountChecksummedAddress(
+          store.getState(),
+        );
+        let parsedCaip10UserAddress;
+        try {
+          parsedCaip10UserAddress = parseCaip10Address(user_address);
+        } catch (error) {
+          throw rpcErrors.invalidParams('Invalid caip-10 user address');
+        }
         const dappConnectedAccount = Object.keys(identities).find(
           (address) =>
             safeToChecksumAddress(address) ===
-            safeToChecksumAddress(user_address),
+            safeToChecksumAddress(parsedCaip10UserAddress.address),
         );
 
         if (!dappConnectedAccount) {
@@ -407,31 +414,57 @@ export const getRpcMethodMiddleware = ({
         }
 
         // This condition is only needed until we support multiple source tokens swap
-        if (from.length > 1) {
+        if (fromToken.length > 1) {
           throw rpcErrors.methodNotSupported(
             'Currently we de not support multiple tokens swap',
           );
         }
 
-        validateParams(from[0], ['token_address'], 'from');
-        validateParams(to, ['token_address'], 'to');
+        validateParams(fromToken[0], ['address'], 'fromToken');
+        validateParams(toToken, ['address'], 'toToken');
 
-        const chainId = selectChainId(store.getState());
+        let parsedCaip10FromTokenAddress;
+        try {
+          parsedCaip10FromTokenAddress = parseCaip10Address(
+            fromToken[0].address,
+          );
+        } catch (error) {
+          throw rpcErrors.invalidParams('Invalid caip-10 fromToken address');
+        }
 
-        const checksummedDappConnectedAccount =
-          safeToChecksumAddress(dappConnectedAccount);
+        let parsedCaip10ToTokenAddress;
+        try {
+          parsedCaip10ToTokenAddress = parseCaip10Address(toToken.address);
+        } catch (error) {
+          throw rpcErrors.invalidParams('Invalid caip-10 toToken address');
+        }
 
         if (
-          safeToChecksumAddress(selectedAddress) !==
-          checksummedDappConnectedAccount
+          parsedCaip10FromTokenAddress.chainId !==
+          parsedCaip10ToTokenAddress.chainId
         ) {
-          Engine.context.PreferencesController.setSelectedAddress(
-            checksummedDappConnectedAccount,
+          throw rpcErrors.methoddNotSupported(
+            'Cross-chain swaps are currently not supported. Both fromToken and toToken must be on the same blockchain.',
           );
         }
 
+        const chainId = selectChainId(store.getState());
+
+        if (chainId !== toHex(parsedCaip10FromTokenAddress.chainId)) {
+          throw rpcErrors.invalidParams(
+            `Invalid parameters: active chainId is different than the one provided.`,
+          );
+        }
+
+        const checksummedDappConnectedAccount =
+          safeToChecksumAddress(dappConnectedAccount);
+
+        if (selectedAddress !== checksummedDappConnectedAccount) {
+          Engine.setSelectedAccount(checksummedDappConnectedAccount);
+        }
+
         // switch to the chain id asked from the dapp
-        // validate if swaps is enable on that network
+        // validate if swaps is enable on that   network
         const swapsIsLive = swapsLivenessSelector(store.getState());
         const isSwappable = isSwapsAllowed(chainId) && swapsIsLive;
 
@@ -446,14 +479,14 @@ export const getRpcMethodMiddleware = ({
           );
         }
         //If value is not defined by the dapp it defaults to 0
-        const decimalWei = parseInt(from[0].value ?? 0, 16);
+        const decimalWei = parseInt(fromToken[0].value ?? 0, 16);
         const tokenAmount = fromWei(decimalWei);
 
         navigation.navigate('Swaps', {
           screen: 'SwapsAmountView',
           params: {
-            sourceToken: from[0].token_address,
-            destinationToken: to.token_address,
+            sourceToken: parsedCaip10FromTokenAddress.address,
+            destinationToken: parsedCaip10ToTokenAddress.address,
             amount: tokenAmount,
           },
         });
diff --git a/app/core/RPCMethods/utils.ts b/app/core/RPCMethods/utils.ts
index 58525377ce3..a29992f9db0 100644
--- a/app/core/RPCMethods/utils.ts
+++ b/app/core/RPCMethods/utils.ts
@@ -1,5 +1,4 @@
 import { query } from '@metamask/controller-utils';
-import { rpcErrors } from '@metamask/rpc-errors';
 import Engine from '../Engine';
 import { selectHooks } from '@metamask/snaps-rpc-methods';
 import { OptionalDataWithOptionalCause, rpcErrors } from '@metamask/rpc-errors';
@@ -135,7 +134,7 @@ export const polyfillGasPrice = async (method: string, params: any[] = []) => {
 };
 
 export const validateParams = (
-  obj: any,
+  obj: Record<string, unknown>,
   properties: string[],
   name: string,
 ): void => {
diff --git a/app/util/caip10Address/index.test.ts b/app/util/caip10Address/index.test.ts
new file mode 100644
index 00000000000..f864064ed22
--- /dev/null
+++ b/app/util/caip10Address/index.test.ts
@@ -0,0 +1,80 @@
+import { parseCaip10Address, Caip10Address } from './';
+import { isValidHexAddress } from '../address';
+
+jest.mock('../address', () => ({
+  isValidHexAddress: jest.fn(),
+}));
+
+const mockIsValidHexAddress = isValidHexAddress as jest.MockedFunction<
+  typeof isValidHexAddress
+>;
+
+describe('parseCaip10Address', () => {
+  beforeEach(() => {
+    // Clear mock implementations before each test to avoid test interference
+    mockIsValidHexAddress.mockClear();
+  });
+  it('parses a valid CAIP-10 address correctly', () => {
+    mockIsValidHexAddress.mockReturnValue(true);
+    const caip10Address = 'eip155:1:0x1234567890abcdefABCDEF1234567890ABCDEF';
+    const expected: Caip10Address = {
+      accountId: 'eip155',
+      chainId: '1',
+      address: '0x1234567890abcdefABCDEF1234567890ABCDEF',
+    };
+    expect(parseCaip10Address(caip10Address)).toEqual(expected);
+  });
+
+  it('throws an error for an address missing parts', () => {
+    const caip10Address = 'eip155:0x1234567890abcdefABCDEF1234567890ABCDEF';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'Invalid CAIP-10 address format',
+    );
+  });
+
+  it('throws an error for an address with too many parts', () => {
+    const caip10Address = 'eip155:1:0x123:ExtraPart';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'Invalid CAIP-10 address format',
+    );
+  });
+
+  it('throws an error for an empty string', () => {
+    const caip10Address = '';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'Invalid CAIP-10 address format',
+    );
+  });
+
+  it('throws an error for an address with spaces', () => {
+    const caip10Address = 'eip155: 1:0x1234567890abcdefABCDEF1234567890ABCDEF';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'CAIP-10 address format cannot contain spaces',
+    );
+  });
+
+  it('throws an error for an Ethereum address with invalid', () => {
+    mockIsValidHexAddress.mockReturnValue(false);
+
+    const caip10Address =
+      'eip155:1:0xGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFASDASFECDAVFSBFV';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'Invalid Ethereum address format',
+    );
+  });
+
+  it('throws an error for an address with additional colons', () => {
+    const caip10Address = 'eip155::1:0x1234567890abcdefABCDEF1234567890ABCDEF';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'Invalid CAIP-10 address format',
+    );
+  });
+
+  it('parses a non-standard blockchain namespace correctly', () => {
+    mockIsValidHexAddress.mockReturnValue(false);
+    const caip10Address = 'cosmos:cosmoshub-4:cosmos1abcdefg';
+    expect(() => parseCaip10Address(caip10Address)).toThrow(
+      'Only support Ethereum addresses at the moment',
+    );
+  });
+});
diff --git a/app/util/caip10Address/index.ts b/app/util/caip10Address/index.ts
new file mode 100644
index 00000000000..1aa289bd2fe
--- /dev/null
+++ b/app/util/caip10Address/index.ts
@@ -0,0 +1,47 @@
+import { isValidHexAddress } from '../address';
+
+// Types for parsed CAIP-10 address components
+export interface Caip10Address {
+  accountId: string;
+  chainId: string;
+  address: string;
+}
+
+/**
+ * Parses a CAIP-10 formatted address into its components.
+ *
+ * CAIP-10 addresses follow the format `namespace:reference:address`,
+ * where `namespace` and `reference` identify the blockchain, and `address`
+ * specifies the account on that blockchain. This function extracts and returns
+ * these components as an object. It throws an error for invalid formats.
+ *
+ * @param {string} caip10Address - The CAIP-10 formatted address to parse.
+ * @returns {Caip10Address} An object containing the parsed `accountId`, `chainId`,                          and `address`.
+ * @throws {Error} If `caip10Address` does not conform to the CAIP-10 format.
+ *
+ * @example
+ * parseCaip10Address('eip155:1:0x1234567890abcdefABCDEF1234567890ABCDEF');
+ * // Returns: { accountId: 'eip155', chainId: '1', address: '0x1234567890abcdefABCDEF1234567890ABCDEF' }
+ */
+export function parseCaip10Address(caip10Address: string): Caip10Address {
+  if (/\s/.test(caip10Address)) {
+    throw new Error('CAIP-10 address format cannot contain spaces');
+  }
+
+  const parts = caip10Address.split(':');
+  if (parts.length !== 3) {
+    throw new Error('Invalid CAIP-10 address format');
+  }
+  const [accountId, chainId, address] = parts;
+
+  // For now we only support EVM addresses, so we only validate those
+  if (accountId === 'eip155') {
+    if (!isValidHexAddress(address)) {
+      throw new Error('Invalid Ethereum address format');
+    }
+  } else {
+    throw new Error('Only support Ethereum addresses at the moment');
+  }
+
+  return { accountId, chainId, address };
+}

From 8287ac89ead7c0694185f560bec456c9cdcdaa4b Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 1 Jul 2024 17:56:03 +0100
Subject: [PATCH 24/29] apply caip 10 util methods from metamask utils repo and
 delete the utils methods added on this PR since no longer needed

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 28 ++++++--
 app/util/caip10Address/index.test.ts       | 80 ----------------------
 app/util/caip10Address/index.ts            | 47 -------------
 3 files changed, 21 insertions(+), 134 deletions(-)
 delete mode 100644 app/util/caip10Address/index.test.ts
 delete mode 100644 app/util/caip10Address/index.ts

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 94c8b323f02..7ea2d75a05f 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -15,6 +15,7 @@ import {
   PermissionController,
   permissionRpcMethods,
 } from '@metamask/permission-controller';
+import { CaipAccountId, parseCaipAccountId } from '@metamask/utils';
 import Networks, {
   blockTagParamIndex,
   getAllNetworks,
@@ -47,7 +48,6 @@ import Logger from '../../../app/util/Logger';
 import DevLogger from '../SDKConnect/utils/DevLogger';
 import { addTransaction } from '../../util/transaction-controller';
 import { selectSelectedInternalAccountChecksummedAddress } from '../../selectors/accountsController';
-import { parseCaip10Address } from '../../util/caip10Address';
 
 // TODO: Replace "any" with type
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -399,10 +399,16 @@ export const getRpcMethodMiddleware = ({
         );
         let parsedCaip10UserAddress;
         try {
-          parsedCaip10UserAddress = parseCaip10Address(user_address);
+          parsedCaip10UserAddress = parseCaipAccountId(
+            user_address as CaipAccountId,
+          );
         } catch (error) {
           throw rpcErrors.invalidParams('Invalid caip-10 user address');
         }
+        if (parsedCaip10UserAddress.chain.namespace !== 'eip155') {
+          throw new Error('Only support Ethereum addresses at the moment');
+        }
+
         const dappConnectedAccount = Object.keys(identities).find(
           (address) =>
             safeToChecksumAddress(address) ===
@@ -425,32 +431,40 @@ export const getRpcMethodMiddleware = ({
 
         let parsedCaip10FromTokenAddress;
         try {
-          parsedCaip10FromTokenAddress = parseCaip10Address(
+          parsedCaip10FromTokenAddress = parseCaipAccountId(
             fromToken[0].address,
           );
         } catch (error) {
           throw rpcErrors.invalidParams('Invalid caip-10 fromToken address');
         }
 
+        if (parsedCaip10FromTokenAddress.chain.namespace !== 'eip155') {
+          throw new Error('Only support Ethereum addresses at the moment');
+        }
+
         let parsedCaip10ToTokenAddress;
         try {
-          parsedCaip10ToTokenAddress = parseCaip10Address(toToken.address);
+          parsedCaip10ToTokenAddress = parseCaipAccountId(toToken.address);
         } catch (error) {
           throw rpcErrors.invalidParams('Invalid caip-10 toToken address');
         }
 
+        if (parsedCaip10ToTokenAddress.chain.namespace !== 'eip155') {
+          throw new Error('Only support Ethereum addresses at the moment');
+        }
+
         if (
           parsedCaip10FromTokenAddress.chainId !==
           parsedCaip10ToTokenAddress.chainId
         ) {
-          throw rpcErrors.methoddNotSupported(
+          throw rpcErrors.methodNotSupported(
             'Cross-chain swaps are currently not supported. Both fromToken and toToken must be on the same blockchain.',
           );
         }
 
         const chainId = selectChainId(store.getState());
 
-        if (chainId !== toHex(parsedCaip10FromTokenAddress.chainId)) {
+        if (chainId !== toHex(parsedCaip10FromTokenAddress.chain.reference)) {
           throw rpcErrors.invalidParams(
             `Invalid parameters: active chainId is different than the one provided.`,
           );
@@ -460,7 +474,7 @@ export const getRpcMethodMiddleware = ({
           safeToChecksumAddress(dappConnectedAccount);
 
         if (selectedAddress !== checksummedDappConnectedAccount) {
-          Engine.setSelectedAccount(checksummedDappConnectedAccount);
+          Engine.setSelectedAddress(checksummedDappConnectedAccount);
         }
 
         // switch to the chain id asked from the dapp
diff --git a/app/util/caip10Address/index.test.ts b/app/util/caip10Address/index.test.ts
deleted file mode 100644
index f864064ed22..00000000000
--- a/app/util/caip10Address/index.test.ts
+++ /dev/null
@@ -1,80 +0,0 @@
-import { parseCaip10Address, Caip10Address } from './';
-import { isValidHexAddress } from '../address';
-
-jest.mock('../address', () => ({
-  isValidHexAddress: jest.fn(),
-}));
-
-const mockIsValidHexAddress = isValidHexAddress as jest.MockedFunction<
-  typeof isValidHexAddress
->;
-
-describe('parseCaip10Address', () => {
-  beforeEach(() => {
-    // Clear mock implementations before each test to avoid test interference
-    mockIsValidHexAddress.mockClear();
-  });
-  it('parses a valid CAIP-10 address correctly', () => {
-    mockIsValidHexAddress.mockReturnValue(true);
-    const caip10Address = 'eip155:1:0x1234567890abcdefABCDEF1234567890ABCDEF';
-    const expected: Caip10Address = {
-      accountId: 'eip155',
-      chainId: '1',
-      address: '0x1234567890abcdefABCDEF1234567890ABCDEF',
-    };
-    expect(parseCaip10Address(caip10Address)).toEqual(expected);
-  });
-
-  it('throws an error for an address missing parts', () => {
-    const caip10Address = 'eip155:0x1234567890abcdefABCDEF1234567890ABCDEF';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'Invalid CAIP-10 address format',
-    );
-  });
-
-  it('throws an error for an address with too many parts', () => {
-    const caip10Address = 'eip155:1:0x123:ExtraPart';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'Invalid CAIP-10 address format',
-    );
-  });
-
-  it('throws an error for an empty string', () => {
-    const caip10Address = '';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'Invalid CAIP-10 address format',
-    );
-  });
-
-  it('throws an error for an address with spaces', () => {
-    const caip10Address = 'eip155: 1:0x1234567890abcdefABCDEF1234567890ABCDEF';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'CAIP-10 address format cannot contain spaces',
-    );
-  });
-
-  it('throws an error for an Ethereum address with invalid', () => {
-    mockIsValidHexAddress.mockReturnValue(false);
-
-    const caip10Address =
-      'eip155:1:0xGHIJKLMNOPQRSTUVWXYZ1234567890ABCDEFASDASFECDAVFSBFV';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'Invalid Ethereum address format',
-    );
-  });
-
-  it('throws an error for an address with additional colons', () => {
-    const caip10Address = 'eip155::1:0x1234567890abcdefABCDEF1234567890ABCDEF';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'Invalid CAIP-10 address format',
-    );
-  });
-
-  it('parses a non-standard blockchain namespace correctly', () => {
-    mockIsValidHexAddress.mockReturnValue(false);
-    const caip10Address = 'cosmos:cosmoshub-4:cosmos1abcdefg';
-    expect(() => parseCaip10Address(caip10Address)).toThrow(
-      'Only support Ethereum addresses at the moment',
-    );
-  });
-});
diff --git a/app/util/caip10Address/index.ts b/app/util/caip10Address/index.ts
deleted file mode 100644
index 1aa289bd2fe..00000000000
--- a/app/util/caip10Address/index.ts
+++ /dev/null
@@ -1,47 +0,0 @@
-import { isValidHexAddress } from '../address';
-
-// Types for parsed CAIP-10 address components
-export interface Caip10Address {
-  accountId: string;
-  chainId: string;
-  address: string;
-}
-
-/**
- * Parses a CAIP-10 formatted address into its components.
- *
- * CAIP-10 addresses follow the format `namespace:reference:address`,
- * where `namespace` and `reference` identify the blockchain, and `address`
- * specifies the account on that blockchain. This function extracts and returns
- * these components as an object. It throws an error for invalid formats.
- *
- * @param {string} caip10Address - The CAIP-10 formatted address to parse.
- * @returns {Caip10Address} An object containing the parsed `accountId`, `chainId`,                          and `address`.
- * @throws {Error} If `caip10Address` does not conform to the CAIP-10 format.
- *
- * @example
- * parseCaip10Address('eip155:1:0x1234567890abcdefABCDEF1234567890ABCDEF');
- * // Returns: { accountId: 'eip155', chainId: '1', address: '0x1234567890abcdefABCDEF1234567890ABCDEF' }
- */
-export function parseCaip10Address(caip10Address: string): Caip10Address {
-  if (/\s/.test(caip10Address)) {
-    throw new Error('CAIP-10 address format cannot contain spaces');
-  }
-
-  const parts = caip10Address.split(':');
-  if (parts.length !== 3) {
-    throw new Error('Invalid CAIP-10 address format');
-  }
-  const [accountId, chainId, address] = parts;
-
-  // For now we only support EVM addresses, so we only validate those
-  if (accountId === 'eip155') {
-    if (!isValidHexAddress(address)) {
-      throw new Error('Invalid Ethereum address format');
-    }
-  } else {
-    throw new Error('Only support Ethereum addresses at the moment');
-  }
-
-  return { accountId, chainId, address };
-}

From 4d634338c07a497ac4786e99408857e19d301a6b Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 1 Jul 2024 18:26:45 +0100
Subject: [PATCH 25/29] fix types on rpc method middleware swapAsset

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 30 +++++++++++++++++++---
 1 file changed, 26 insertions(+), 4 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 7ea2d75a05f..4e9489c6962 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -15,7 +15,14 @@ import {
   PermissionController,
   permissionRpcMethods,
 } from '@metamask/permission-controller';
-import { CaipAccountId, parseCaipAccountId } from '@metamask/utils';
+import {
+  CaipAccountAddress,
+  CaipAccountId,
+  CaipChainId,
+  CaipNamespace,
+  CaipReference,
+  parseCaipAccountId,
+} from '@metamask/utils';
 import Networks, {
   blockTagParamIndex,
   getAllNetworks,
@@ -397,7 +404,12 @@ export const getRpcMethodMiddleware = ({
         const selectedAddress = selectSelectedInternalAccountChecksummedAddress(
           store.getState(),
         );
-        let parsedCaip10UserAddress;
+        // Implement on utils repo a interface for this
+        let parsedCaip10UserAddress: {
+          address: CaipAccountAddress;
+          chainId: CaipChainId;
+          chain: { namespace: CaipNamespace; reference: CaipReference };
+        };
         try {
           parsedCaip10UserAddress = parseCaipAccountId(
             user_address as CaipAccountId,
@@ -429,7 +441,12 @@ export const getRpcMethodMiddleware = ({
         validateParams(fromToken[0], ['address'], 'fromToken');
         validateParams(toToken, ['address'], 'toToken');
 
-        let parsedCaip10FromTokenAddress;
+        // Implement on utils repo a interface for this
+        let parsedCaip10FromTokenAddress: {
+          address: CaipAccountAddress;
+          chainId: CaipChainId;
+          chain: { namespace: CaipNamespace; reference: CaipReference };
+        };
         try {
           parsedCaip10FromTokenAddress = parseCaipAccountId(
             fromToken[0].address,
@@ -442,7 +459,12 @@ export const getRpcMethodMiddleware = ({
           throw new Error('Only support Ethereum addresses at the moment');
         }
 
-        let parsedCaip10ToTokenAddress;
+        // Implement on utils repo a interface for this
+        let parsedCaip10ToTokenAddress: {
+          address: CaipAccountAddress;
+          chainId: CaipChainId;
+          chain: { namespace: CaipNamespace; reference: CaipReference };
+        };
         try {
           parsedCaip10ToTokenAddress = parseCaipAccountId(toToken.address);
         } catch (error) {

From b32dc5710d093425026b482320fcc553e8eca4c2 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 1 Jul 2024 19:00:01 +0100
Subject: [PATCH 26/29] fix typescript issues on rpcmethod middleware

---
 .../RPCMethods/RPCMethodMiddleware.test.ts    | 81 ++++++++-----------
 1 file changed, 33 insertions(+), 48 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index 1ce91c4442b..6129437d622 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -21,7 +21,6 @@ import {
 } from '@metamask/permission-controller';
 import PPOMUtil from '../../lib/ppom/ppom-util';
 import initialBackgroundState from '../../util/test/initial-background-state.json';
-import { Store } from 'redux';
 import { RootState } from 'app/reducers';
 import { addTransaction } from '../../util/transaction-controller';
 import { ControllerMessenger } from '@metamask/base-controller';
@@ -31,6 +30,8 @@ import {
   unrestrictedMethods,
 } from '../Permissions/specifications';
 import { EthAccountType, EthMethod } from '@metamask/keyring-api';
+import initialRootState from '../../util/test/initial-root-state';
+import { merge } from 'lodash';
 
 jest.mock('../Engine', () => ({
   context: {
@@ -231,29 +232,23 @@ function setupGlobalState({
   providerConfig?: ProviderConfig;
   selectedAddress?: string;
 }) {
-  // TODO: Remove any cast once PermissionController type is fixed. Currently, the state shows never.
-  jest
-    // TODO: Replace "any" with type
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    .spyOn(store as Store<Partial<RootState>, any>, 'getState')
-    .mockImplementation(() => ({
-      browser: activeTab
-        ? {
-            activeTab,
-          }
-        : {},
-      engine: {
-        backgroundState: {
-          ...initialBackgroundState,
-          NetworkController: {
-            providerConfig: providerConfig || {},
-          },
-          PreferencesController: selectedAddress ? { selectedAddress } : {},
+  const mockState: RootState = merge({}, initialRootState, {
+    browser: activeTab
+      ? {
+          activeTab,
+        }
+      : {},
+    engine: {
+      backgroundState: {
+        ...initialBackgroundState,
+        NetworkController: {
+          providerConfig: providerConfig || {},
         },
-        // TODO: Replace "any" with type
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      } as any,
-    }));
+        PreferencesController: selectedAddress ? { selectedAddress } : {},
+      },
+    },
+  });
+  jest.spyOn(store, 'getState').mockImplementation(() => mockState);
   mockStore.dispatch.mockImplementation((obj) => obj);
   if (addTransactionResult) {
     mockAddTransaction.mockImplementation(async () => ({
@@ -1296,7 +1291,7 @@ describe('getRpcMethodMiddleware', () => {
   });
   describe('wallet_swapAsset', () => {
     it('should throw error if the account sent by the dapp is not the one connected', async () => {
-      const mockState = {
+      const mockState: RootState = merge({}, initialRootState, {
         swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
           networks: [
@@ -1329,10 +1324,8 @@ describe('getRpcMethodMiddleware', () => {
             },
           },
         },
-      };
-      jest
-        .spyOn(store as Store<Partial<any>, any>, 'getState')
-        .mockImplementation(() => mockState);
+      });
+      jest.spyOn(store, 'getState').mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1368,7 +1361,7 @@ describe('getRpcMethodMiddleware', () => {
     });
 
     it('should throw error if it was sent more than one token to swap from', async () => {
-      const mockState = {
+      const mockState: RootState = merge({}, initialRootState, {
         swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
           networks: [
@@ -1401,10 +1394,8 @@ describe('getRpcMethodMiddleware', () => {
             },
           },
         },
-      };
-      jest
-        .spyOn(store as Store<Partial<any>, any>, 'getState')
-        .mockImplementation(() => mockState);
+      });
+      jest.spyOn(store, 'getState').mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1445,7 +1436,7 @@ describe('getRpcMethodMiddleware', () => {
     });
 
     it('should throw error if token_address required param is not defined', async () => {
-      const mockState = {
+      const mockState = merge({}, initialRootState, {
         swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
           networks: [
@@ -1478,10 +1469,8 @@ describe('getRpcMethodMiddleware', () => {
             },
           },
         },
-      };
-      jest
-        .spyOn(store as Store<Partial<any>, any>, 'getState')
-        .mockImplementation(() => mockState);
+      });
+      jest.spyOn(store, 'getState').mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1516,7 +1505,7 @@ describe('getRpcMethodMiddleware', () => {
     });
 
     it('should throw error if swap is not live', async () => {
-      const mockState = {
+      const mockState = merge({}, initialRootState, {
         swaps: { '0x1': { isLive: false }, hasOnboarded: false, isLive: false },
         fiatOrders: {
           networks: [
@@ -1549,10 +1538,8 @@ describe('getRpcMethodMiddleware', () => {
             },
           },
         },
-      };
-      jest
-        .spyOn(store as Store<Partial<any>, any>, 'getState')
-        .mockImplementation(() => mockState);
+      });
+      jest.spyOn(store, 'getState').mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',
@@ -1588,7 +1575,7 @@ describe('getRpcMethodMiddleware', () => {
     });
 
     it('should navigate to SwapsAmountView if all conditions are met', async () => {
-      const mockState = {
+      const mockState = merge({}, initialRootState, {
         swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
           networks: [
@@ -1621,10 +1608,8 @@ describe('getRpcMethodMiddleware', () => {
             },
           },
         },
-      };
-      jest
-        .spyOn(store as Store<Partial<any>, any>, 'getState')
-        .mockImplementation(() => mockState);
+      });
+      jest.spyOn(store, 'getState').mockImplementation(() => mockState);
       const middleware = getRpcMethodMiddleware({
         ...getMinimalOptions(),
         hostname: 'example.metamask.io',

From 9d8376d7d98a8ee6ce0f51c45bbf0502373a97a5 Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 1 Jul 2024 19:22:52 +0100
Subject: [PATCH 27/29] fix unit tests

---
 .../RPCMethods/RPCMethodMiddleware.test.ts    | 56 +++++++++----------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index 6129437d622..b30844faf29 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -53,6 +53,7 @@ jest.mock('../Engine', () => ({
       },
     },
   },
+  setSelectedAddress: jest.fn(),
 }));
 const MockEngine = jest.mocked(Engine);
 
@@ -1336,19 +1337,19 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: [
+            fromToken: [
               {
                 // DAI address
-                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                address: '0x6b175474e89094c44da98b954eedeac495271d0f',
                 value: '0xDE0B6B3A7640000',
               },
             ],
-            to: {
+            toToken: {
               chainId: '0x1',
               // ETH address
-              token_address: '0x0000000000000000000000000000000000000000',
+              address: '0x0000000000000000000000000000000000000000',
             },
-            user_address: '0x0',
+            userAddress: 'eip155:1:0x0',
           },
         ],
       };
@@ -1406,24 +1407,24 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: [
+            fromToken: [
               {
                 // DAI address
-                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                address: '0x6b175474e89094c44da98b954eedeac495271d0f',
                 value: '0xDE0B6B3A7640000',
               },
               {
                 // ETH address
-                token_address: '0x0000000000000000000000000000000000000000',
+                address: '0x0000000000000000000000000000000000000000',
                 value: '0xDE0B6B3A7640000',
               },
             ],
-            to: {
+            toToken: {
               chainId: '0x1',
               // ETH address
-              token_address: '0x0000000000000000000000000000000000000000',
+              address: '0x0000000000000000000000000000000000000000',
             },
-            user_address: '0x0',
+            userAddress: 'eip155:1:0x0',
           },
         ],
       };
@@ -1435,7 +1436,7 @@ describe('getRpcMethodMiddleware', () => {
       );
     });
 
-    it('should throw error if token_address required param is not defined', async () => {
+    it('should throw error if address required param is not defined', async () => {
       const mockState = merge({}, initialRootState, {
         swaps: { '0x1': { isLive: true }, hasOnboarded: false, isLive: true },
         fiatOrders: {
@@ -1481,18 +1482,18 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: [
+            fromToken: [
               {
                 // DAI address
                 value: '0xDE0B6B3A7640000',
               },
             ],
-            to: {
+            toToken: {
               chainId: '0x1',
               // ETH address
-              token_address: '0x0000000000000000000000000000000000000000',
+              address: 'eip155:1:0x0000000000000000000000000000000000000000',
             },
-            user_address: '0x0',
+            userAddress: 'eip155:1:0x0',
           },
         ],
       };
@@ -1500,7 +1501,7 @@ describe('getRpcMethodMiddleware', () => {
       const response = await callMiddleware({ middleware, request });
       //@ts-expect-error now the response can have an error property
       await expect(response?.error?.message).toStrictEqual(
-        'token_address property of from is not defined',
+        'address property of fromToken is not defined',
       );
     });
 
@@ -1550,19 +1551,18 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: [
+            fromToken: [
               {
                 // DAI address
-                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                address: 'eip155:1:0x6b175474e89094c44da98b954eedeac495271d0f',
                 value: '0xDE0B6B3A7640000',
               },
             ],
-            to: {
-              chainId: '0x1',
+            toToken: {
               // ETH address
-              token_address: '0x0000000000000000000000000000000000000000',
+              address: 'eip155:1:0x0000000000000000000000000000000000000000',
             },
-            user_address: '0x0',
+            userAddress: 'eip155:1:0x0',
           },
         ],
       };
@@ -1620,20 +1620,20 @@ describe('getRpcMethodMiddleware', () => {
         method: 'wallet_swapAsset',
         params: [
           {
-            from: [
+            fromToken: [
               {
                 chainId: '0x1',
                 // DAI address
-                token_address: '0x6b175474e89094c44da98b954eedeac495271d0f',
+                address: 'eip155:1:0x6b175474e89094c44da98b954eedeac495271d0f',
                 value: '0xDE0B6B3A7640000',
               },
             ],
-            to: {
+            toToken: {
               chainId: '0x1',
               // ETH address
-              token_address: '0x0000000000000000000000000000000000000000',
+              address: 'eip155:1:0x0000000000000000000000000000000000000000',
             },
-            user_address: '0x0',
+            userAddress: 'eip155:1:0x0',
           },
         ],
       };

From c430b11e862e9e8c1f82f2da6317d82e1b1e5e1e Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Mon, 1 Jul 2024 22:57:47 +0100
Subject: [PATCH 28/29] user_address to userAddress

---
 app/core/RPCMethods/RPCMethodMiddleware.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 4e9489c6962..22e6ae1e45a 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -399,7 +399,7 @@ export const getRpcMethodMiddleware = ({
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const rpcMethods: any = {
       wallet_swapAsset: async () => {
-        const { fromToken, toToken, user_address } = req.params[0];
+        const { fromToken, toToken, userAddress } = req.params[0];
         const identities = selectIdentities(store.getState());
         const selectedAddress = selectSelectedInternalAccountChecksummedAddress(
           store.getState(),
@@ -412,7 +412,7 @@ export const getRpcMethodMiddleware = ({
         };
         try {
           parsedCaip10UserAddress = parseCaipAccountId(
-            user_address as CaipAccountId,
+            userAddress as CaipAccountId,
           );
         } catch (error) {
           throw rpcErrors.invalidParams('Invalid caip-10 user address');

From e56bd3b146023366d67a94bd3eb08d6a30c042fd Mon Sep 17 00:00:00 2001
From: tommasini <tommasini15@gmail.com>
Date: Tue, 2 Jul 2024 12:07:22 +0100
Subject: [PATCH 29/29] update the swap could not be completed as requested

---
 app/core/RPCMethods/RPCMethodMiddleware.test.ts | 2 +-
 app/core/RPCMethods/RPCMethodMiddleware.ts      | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/app/core/RPCMethods/RPCMethodMiddleware.test.ts b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
index b30844faf29..c9e66248e53 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.test.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.test.ts
@@ -1357,7 +1357,7 @@ describe('getRpcMethodMiddleware', () => {
       const response = await callMiddleware({ middleware, request });
       //@ts-expect-error now the response can have an error property
       await expect(response?.error?.message).toStrictEqual(
-        'This address does not exist',
+        'The swap could not be completed as requested',
       );
     });
 
diff --git a/app/core/RPCMethods/RPCMethodMiddleware.ts b/app/core/RPCMethods/RPCMethodMiddleware.ts
index 22e6ae1e45a..94ee918b3a0 100644
--- a/app/core/RPCMethods/RPCMethodMiddleware.ts
+++ b/app/core/RPCMethods/RPCMethodMiddleware.ts
@@ -428,7 +428,9 @@ export const getRpcMethodMiddleware = ({
         );
 
         if (!dappConnectedAccount) {
-          throw rpcErrors.invalidParams('This address does not exist');
+          throw rpcErrors.invalidParams(
+            'The swap could not be completed as requested',
+          );
         }
 
         // This condition is only needed until we support multiple source tokens swap