Merge pull request #15248 from brave/f/wallet/jupiter-fees

feat(wallet): charge Jupiter fees for selective output mints

Author: onyb

components/brave_wallet/browser/brave_wallet_constants.cc

@@ -6,6 +6,7 @@
 #include <map>
 #include <string>
 
+#include "base/containers/contains.h"
 #include "brave/components/brave_wallet/browser/brave_wallet_constants.h"
 
 namespace brave_wallet {
@@ -295,4 +296,20 @@ const base::flat_map<std::string, std::string>& GetInfuraChainEndpoints() {
   return *endpoints;
 }
 
+bool HasJupiterFeesForTokenMint(const std::string& mint) {
+  static std::vector<std::string> mints(
+      {"So11111111111111111111111111111111111111112",     // wSOL
+       "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",    // USDC
+       "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",    // USDT
+       "7vfCXTUXx5WJV5JADk17DUJ4ksgau7utNKj4b963voxs"     // WETH (Wormhole)
+       "2FPyTwcZLUg1MDrwsyoP4D6s1tM7hAkHYRjkNb5w6Pxk"     // ETH (Sollet)
+       "9n4nbM75f5Ui33ZbPYXn59EwSgE8CGsHtAeTH5YFeJ9E",    // BTC (Sollet)
+       "qfnqNqs3nCAHjnyCgLRDbBtq4p2MtHZxw8YjSyYhPoL",     // wWBTC (Wormhole)
+       "7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj",    // stSOL
+       "mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So",     // mSOL
+       "FYpdBuyAHSbdaAyD1sKkxyLWbAP8uUW9h6uvdhK74ij1"});  // DAI
+
+  return base::Contains(mints, mint);
+}
+
 }  // namespace brave_wallet

components/brave_wallet/browser/brave_wallet_constants.h

@@ -986,6 +986,7 @@ const std::vector<mojom::OnRampCurrency>& GetOnRampCurrenciesList();
 const std::vector<mojom::BlockchainToken>& GetSardineBuyTokens();
 const std::string GetSardineNetworkName(const std::string& chain_id);
 const base::flat_map<std::string, std::string>& GetInfuraChainEndpoints();
+bool HasJupiterFeesForTokenMint(const std::string& mint);
 
 }  // namespace brave_wallet
 

components/brave_wallet/browser/swap_request_helper.cc

@@ -22,15 +22,24 @@ absl::optional<std::string> EncodeJupiterTransactionParams(
   DCHECK(params);
   base::Value::Dict tx_params;
 
-  // feeAccount is the ATA account for the output mint where the fee will be
-  // sent to.
+  // The code below does the following two things:
+  //   - compute the ATA address that should be used to receive fees
+  //   - verify if output_mint is a valid address
   absl::optional<std::string> associated_token_account =
       SolanaKeyring::GetAssociatedTokenAccount(
           params->output_mint, brave_wallet::kSolanaFeeRecipient);
   if (!associated_token_account)
     return absl::nullopt;
 
-  tx_params.Set("feeAccount", *associated_token_account);
+  // If the if-condition below is false, associated_token_account is unused,
+  // but the originating call to SolanaKeyring::GetAssociatedTokenAccount()
+  // is still done to ensure output_mint is always valid.
+  if (HasJupiterFeesForTokenMint(params->output_mint)) {
+    // feeAccount is the ATA account for the output mint where the fee will be
+    // sent to.
+    tx_params.Set("feeAccount", *associated_token_account);
+  }
+
   tx_params.Set("userPublicKey", params->user_public_key);
 
   base::Value::Dict route;

components/brave_wallet/browser/swap_request_helper_unittest.cc

@@ -105,16 +105,60 @@ TEST(SwapRequestHelperUnitTest, EncodeJupiterTransactionParams) {
       "userPublicKey": "mockPubKey"
     })");
 
+  // OK: Jupiter transaction params with feeAccount
   auto expected_params_value = base::JSONReader::Read(
       expected_params,
       base::JSON_PARSE_CHROMIUM_EXTENSIONS | base::JSON_ALLOW_TRAILING_COMMAS);
   ASSERT_NE(encoded_params, absl::nullopt);
   ASSERT_EQ(*encoded_params, GetJSON(*expected_params_value));
 
-  // Empty params
+  // OK: Jupiter transaction params WITHOUT feeAccount
+  params.output_mint = "SHDWyBxihqiCj6YekG2GUr7wqKLeLAMK1gHZck9pL6y";  // SHDW
+  encoded_params = EncodeJupiterTransactionParams(params.Clone());
+  expected_params = R"(
+    {
+      "route": {
+        "inAmount": 10000,
+        "outAmount": 261273,
+        "amount": 10000,
+        "otherAmountThreshold": 258660,
+        "swapMode": "ExactIn",
+        "priceImpactPct": 0.008955716118219659,
+        "marketInfos": [
+          {
+            "id": "2yNwARmTmc3NzYMETCZQjAE5GGCPgviH6hiBsxaeikTK",
+            "label": "Orca",
+            "inputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+            "outputMint": "MNDEFzGvMt87ueuHvVU9VcTqsAP5b3fTGPsHuuPA5ey",
+            "notEnoughLiquidity": false,
+            "inAmount": 10000,
+            "outAmount": 117001203,
+            "priceImpactPct": 1.196568750220778e-7,
+            "lpFee": {
+              "amount": 30,
+              "mint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+              "pct": 0.003
+            },
+            "platformFee": {
+              "amount": 0,
+              "mint": "MNDEFzGvMt87ueuHvVU9VcTqsAP5b3fTGPsHuuPA5ey",
+              "pct": 0.0
+            }
+          }
+        ]
+      },
+      "userPublicKey": "mockPubKey"
+    })";
+  expected_params_value = base::JSONReader::Read(
+      expected_params,
+      base::JSON_PARSE_CHROMIUM_EXTENSIONS | base::JSON_ALLOW_TRAILING_COMMAS);
+  ASSERT_NE(encoded_params, absl::nullopt);
+  ASSERT_EQ(*encoded_params, GetJSON(*expected_params_value));
+
+  // KO: empty params
   EXPECT_DCHECK_DEATH(EncodeJupiterTransactionParams(nullptr));
 
-  // Invalid output mint
+  // KO: invalid output mint
   params.output_mint = "invalid output mint";
   encoded_params = EncodeJupiterTransactionParams(params.Clone());
   ASSERT_EQ(encoded_params, absl::nullopt);

components/brave_wallet/browser/swap_service.cc

@@ -105,8 +105,12 @@ GURL AppendJupiterQuoteParams(
     url = net::AppendQueryParameter(url, "outputMint", params.output_mint);
   if (!params.amount.empty())
     url = net::AppendQueryParameter(url, "amount", params.amount);
-  url = net::AppendQueryParameter(url, "feeBps",
-                                  brave_wallet::SwapService::GetFee(chain_id));
+
+  if (brave_wallet::HasJupiterFeesForTokenMint(params.output_mint)) {
+    url = net::AppendQueryParameter(
+        url, "feeBps", brave_wallet::SwapService::GetFee(chain_id));
+  }
+
   url = net::AppendQueryParameter(
       url, "slippage", base::StringPrintf("%.6f", params.slippage_percentage));
 
@@ -447,4 +451,10 @@ void SwapService::OnGetJupiterSwapTransactions(
   std::move(callback).Run(true, std::move(swap_transactions), absl::nullopt);
 }
 
+void SwapService::HasJupiterFeesForTokenMint(
+    const std::string& mint,
+    HasJupiterFeesForTokenMintCallback callback) {
+  std::move(callback).Run(brave_wallet::HasJupiterFeesForTokenMint(mint));
+}
+
 }  // namespace brave_wallet

components/brave_wallet/browser/swap_service.h

@@ -78,6 +78,10 @@ class SwapService : public KeyedService, public mojom::SwapService {
       mojom::JupiterSwapParamsPtr params,
       GetJupiterSwapTransactionsCallback callback) override;
 
+  void HasJupiterFeesForTokenMint(
+      const std::string& mint,
+      HasJupiterFeesForTokenMintCallback callback) override;
+
   static void SetBaseURLForTest(const GURL& base_url_for_test);
 
  private:

components/brave_wallet/browser/swap_service_unittest.cc

@@ -452,8 +452,11 @@ TEST_F(SwapServiceUnitTest, IsSwapSupported) {
   EXPECT_FALSE(IsSwapSupported("invalid chain_id"));
 }
 TEST_F(SwapServiceUnitTest, GetJupiterQuoteURL) {
-  auto url = swap_service_->GetJupiterQuoteURL(GetCannedJupiterQuoteParams(),
-                                               mojom::kSolanaMainnet);
+  auto params = GetCannedJupiterQuoteParams();
+  auto url =
+      swap_service_->GetJupiterQuoteURL(params.Clone(), mojom::kSolanaMainnet);
+
+  // OK: output mint has Jupiter fees
   ASSERT_EQ(url,
             "https://quote-api.jup.ag/v1/quote?"
             "inputMint=So11111111111111111111111111111111111111112&"
@@ -462,6 +465,19 @@ TEST_F(SwapServiceUnitTest, GetJupiterQuoteURL) {
             "feeBps=85&"
             "slippage=0.500000&"
             "onlyDirectRoutes=true");
+
+  params->output_mint = "SHDWyBxihqiCj6YekG2GUr7wqKLeLAMK1gHZck9pL6y";
+  url =
+      swap_service_->GetJupiterQuoteURL(params.Clone(), mojom::kSolanaMainnet);
+
+  // OK: output mint does not have Jupiter fees
+  ASSERT_EQ(url,
+            "https://quote-api.jup.ag/v1/quote?"
+            "inputMint=So11111111111111111111111111111111111111112&"
+            "outputMint=SHDWyBxihqiCj6YekG2GUr7wqKLeLAMK1gHZck9pL6y&"
+            "amount=10000&"
+            "slippage=0.500000&"
+            "onlyDirectRoutes=true");
 }
 
 TEST_F(SwapServiceUnitTest, GetJupiterSwapTransactionsURL) {

components/brave_wallet/common/brave_wallet.mojom

@@ -713,6 +713,10 @@ interface SwapService {
 
   // Obtains whether the given chain id supports swap
   IsSwapSupported(string chain_id) => (bool result);
+
+  // Obtains whether the given Solana token mint should have fees for Jupiter
+  // swaps.
+  HasJupiterFeesForTokenMint(string mint) => (bool result);
 };
 
 interface JsonRpcServiceObserver {

components/brave_wallet_ui/common/async/lib.ts

@@ -322,6 +322,11 @@ export async function getIsSwapSupported (network: BraveWallet.NetworkInfo): Pro
   return (await swapService.isSwapSupported(network.chainId)).result
 }
 
+export async function hasJupiterFeesForMint (mint: string): Promise<boolean> {
+  const { swapService } = getAPIProxy()
+  return (await swapService.hasJupiterFeesForTokenMint(mint)).result
+}
+
 export function refreshVisibleTokenInfo (currentNetwork: BraveWallet.NetworkInfo) {
   return async (dispatch: Dispatch, getState: () => State) => {
     const { braveWalletService } = getAPIProxy()

components/brave_wallet_ui/components/buy-send-swap/swap/index.tsx

@@ -2,13 +2,7 @@ import * as React from 'react'
 import { useSelector } from 'react-redux'
 
 import { getLocale, splitStringForTag } from '../../../../common/locale'
-import {
-  AmountPresetTypes,
-  BraveWallet,
-  BuySendSwapViewTypes,
-  ToOrFromType,
-  WalletState
-} from '../../../constants/types'
+import { AmountPresetTypes, BraveWallet, BuySendSwapViewTypes, ToOrFromType, WalletState } from '../../../constants/types'
 import SwapInputComponent from '../swap-input-component'
 import { SwapTooltip } from '../../desktop'
 
@@ -29,7 +23,7 @@ import {
 } from './style'
 import { LoaderIcon } from 'brave-ui/components/icons'
 import { ResetButton } from '../shared-styles'
-import { useSwap } from '../../../common/hooks'
+import { useLib, useSwap } from '../../../common/hooks'
 import { SwapProvider } from '../../../common/hooks/swap'
 
 export interface Props {
@@ -100,6 +94,25 @@ function Swap (props: Props) {
     selectedNetwork
   } = useSelector((state: { wallet: WalletState }) => state.wallet)
 
+  const [hasFees, setHasFees] = React.useState<boolean>(true)
+  const { hasJupiterFeesForMint } = useLib()
+
+  React.useEffect(() => {
+    (async () => {
+      if (swapProvider === SwapProvider.ZeroEx) {
+        setHasFees(true)
+        return
+      }
+
+      if (!toAsset) {
+        return
+      }
+
+      const result = await hasJupiterFeesForMint(toAsset.contractAddress)
+      setHasFees(result)
+    })()
+  }, [toAsset, swapProvider])
+
   const onShowAssetTo = () => {
     onChangeSwapView('assets', 'to')
     onFilterAssetList(fromAsset)
@@ -241,7 +254,7 @@ function Swap (props: Props) {
       </ResetButton>
       <SwapFeesNoticeRow>
         <SwapFeesNoticeText>
-          {getLocale('braveWalletSwapFeesNotice')
+          {hasFees && getLocale('braveWalletSwapFeesNotice')
             .replace('$1', swapProvider === SwapProvider.Jupiter
               ? '0.85%'
               : '0.875%')}