chore: use api endpoints for swap logic (brave#21454)

* chore: use api endpoints for swap logic

* chore: move sendSolanaSerializedTransaction to a mutation

components/brave_wallet_ui/common/async/lib.ts

@@ -8,10 +8,7 @@ import { mapLimit } from 'async'
 import {
   HardwareWalletConnectOpts //
 } from '../../components/desktop/popup-modals/add-account-modal/hardware-wallet-connect/types'
-import {
-  BraveWallet,
-  SolanaSerializedTransactionParams
-} from '../../constants/types'
+import { BraveWallet } from '../../constants/types'
 import * as WalletActions from '../actions/wallet_actions'
 
 // Utils
@@ -49,7 +46,6 @@ import {
   isIpfs,
   stripERC20TokenImageURL
 } from '../../utils/string-utils'
-import { toTxDataUnion } from '../../utils/tx-utils'
 
 export const onConnectHardwareWallet = (
   opts: HardwareWalletConnectOpts
@@ -178,33 +174,6 @@ export function refreshVisibleTokenInfo(
   }
 }
 
-export async function sendSolanaSerializedTransaction(
-  payload: SolanaSerializedTransactionParams
-) {
-  const { solanaTxManagerProxy, txService } = getAPIProxy()
-  const result =
-    await solanaTxManagerProxy.makeTxDataFromBase64EncodedTransaction(
-      payload.encodedTransaction,
-      payload.txType,
-      payload.sendOptions || null
-    )
-  if (result.error !== BraveWallet.ProviderError.kSuccess) {
-    console.error(`Failed to sign Solana message: ${result.errorMessage}`)
-    return { success: false, errorMessage: result.errorMessage, txMetaId: '' }
-  }
-
-  return await txService.addUnapprovedTransaction(
-    toTxDataUnion({ solanaTxData: result.txData ?? undefined }),
-    payload.chainId,
-    payload.accountId
-  )
-}
-
-export function getSwapService() {
-  const { swapService } = getAPIProxy()
-  return swapService
-}
-
 export async function getNFTMetadata(token: BraveWallet.BlockchainToken) {
   const { jsonRpcService } = getAPIProxy()
   if (token.coin === BraveWallet.CoinType.ETH) {

components/brave_wallet_ui/common/slices/api.slice.ts

@@ -46,6 +46,7 @@ import { tokenBalancesEndpoints } from './endpoints/token_balances.endpoints'
 import { fiatCurrencyEndpoints } from './endpoints/fiat_currency.endpoints'
 import { sitePermissionEndpoints } from './endpoints/site_permissions.endpoints'
 import { transactionEndpoints } from './endpoints/transaction.endpoints'
+import { swapEndpoints } from './endpoints/swap.endpoints'
 
 export function createWalletApi() {
   // base to add endpoints to
@@ -146,6 +147,8 @@ export function createWalletApi() {
       .injectEndpoints({ endpoints: fiatCurrencyEndpoints })
       // Site permission (connected accounts) endpoints
       .injectEndpoints({ endpoints: sitePermissionEndpoints })
+      // Brave Swap endpoints
+      .injectEndpoints({ endpoints: swapEndpoints })
   )
 }
 
@@ -171,7 +174,10 @@ export const {
   useConnectToSiteMutation,
   useCreateWalletMutation,
   useEnableEnsOffchainLookupMutation,
+  useGenerateBraveSwapFeeMutation,
   useGenerateReceiveAddressMutation,
+  useGenerateSwapQuoteMutation,
+  useGenerateSwapTransactionMutation,
   useGetAccountInfosRegistryQuery,
   useGetAccountTokenCurrentBalanceQuery,
   useGetActiveOriginConnectedAccountIdsQuery,
@@ -290,6 +296,7 @@ export const {
   useSendETHFilForwarderTransferMutation,
   useSendEvmTransactionMutation,
   useSendFilTransactionMutation,
+  useSendSolanaSerializedTransactionMutation,
   useSendSolTransactionMutation,
   useSendSPLTransferMutation,
   useSendZecTransactionMutation,

components/brave_wallet_ui/common/slices/endpoints/swap.endpoints.ts

@@ -0,0 +1,92 @@
+// Copyright (c) 2023 The Brave Authors. All rights reserved.
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this file,
+// You can obtain one at https://mozilla.org/MPL/2.0/.
+
+// types
+import { BraveWallet } from '../../../constants/types'
+import { WalletApiEndpointBuilderParams } from '../api-base.slice'
+
+// utils
+import { handleEndpointError } from '../../../utils/api-utils'
+
+export const swapEndpoints = ({
+  mutation,
+  query
+}: WalletApiEndpointBuilderParams) => {
+  return {
+    generateBraveSwapFee: mutation<
+      {
+        response: BraveWallet.BraveSwapFeeResponse | null
+        errorString: string
+      },
+      BraveWallet.BraveSwapFeeParams
+    >({
+      queryFn: async (params, { endpoint }, extraOptions, baseQuery) => {
+        const { swapService } = baseQuery(undefined).data
+        try {
+          const result = await swapService.getBraveFee(params)
+          return {
+            data: result
+          }
+        } catch (error) {
+          return handleEndpointError(
+            endpoint,
+            'Unable to fetch Brave Swap fee',
+            error
+          )
+        }
+      }
+    }),
+
+    generateSwapQuote: mutation<
+      {
+        response: BraveWallet.SwapQuoteUnion | null
+        error: BraveWallet.SwapErrorUnion | null
+        errorString: string
+      },
+      BraveWallet.SwapQuoteParams
+    >({
+      queryFn: async (params, { endpoint }, extraOptions, baseQuery) => {
+        const { swapService } = baseQuery(undefined).data
+        try {
+          const result = await swapService.getQuote(params)
+          return {
+            data: result
+          }
+        } catch (error) {
+          return handleEndpointError(
+            endpoint,
+            'Unable to generate Brave Swap quote',
+            error
+          )
+        }
+      }
+    }),
+
+    generateSwapTransaction: mutation<
+      {
+        response: BraveWallet.SwapTransactionUnion | null
+        error: BraveWallet.SwapErrorUnion | null
+        errorString: string
+      },
+      BraveWallet.SwapTransactionParamsUnion
+    >({
+      queryFn: async (params, { endpoint }, extraOptions, baseQuery) => {
+        const { swapService } = baseQuery(undefined).data
+        try {
+          const result = await swapService.getTransaction(params)
+          return {
+            data: result
+          }
+        } catch (error) {
+          return handleEndpointError(
+            endpoint,
+            'Unable to generate Brave Swap transaction',
+            error
+          )
+        }
+      }
+    })
+  }
+}

components/brave_wallet_ui/common/slices/endpoints/transaction.endpoints.ts

@@ -281,6 +281,59 @@ export const transactionEndpoints = ({
         })
     }),
 
+    sendSolanaSerializedTransaction: mutation<
+      boolean, // success,
+      {
+        encodedTransaction: string
+        chainId: string
+        accountId: BraveWallet.AccountId
+        txType: BraveWallet.TransactionType
+        sendOptions?: BraveWallet.SolanaSendTransactionOptions
+      }
+    >({
+      queryFn: async (payload, { endpoint }, extraOptions, baseQuery) => {
+        try {
+          const { data: api } = baseQuery(undefined)
+          const { solanaTxManagerProxy, txService } = api
+          const result =
+            await solanaTxManagerProxy.makeTxDataFromBase64EncodedTransaction(
+              payload.encodedTransaction,
+              payload.txType,
+              payload.sendOptions || null
+            )
+
+          if (result.error !== BraveWallet.ProviderError.kSuccess) {
+            throw new Error(
+              `Failed to sign Solana message: ${result.errorMessage}`
+            )
+          }
+
+          const { errorMessage, success } =
+            await txService.addUnapprovedTransaction(
+              toTxDataUnion({ solanaTxData: result.txData ?? undefined }),
+              payload.chainId,
+              payload.accountId
+            )
+
+          if (!success) {
+            throw new Error(
+              `Error creating Solana transaction: ${errorMessage}`
+            )
+          }
+
+          return {
+            data: success
+          }
+        } catch (error) {
+          return handleEndpointError(
+            endpoint,
+            'Failed to send Solana serialized transaction',
+            error
+          )
+        }
+      }
+    }),
+
     // BTC
     sendBtcTransaction: mutation<
       { success: boolean },

components/brave_wallet_ui/constants/types.ts

@@ -344,14 +344,6 @@ export interface SPLTransferFromParams extends BaseTransactionParams {
   splTokenMintAddress: string
 }
 
-export interface SolanaSerializedTransactionParams {
-  encodedTransaction: string
-  chainId: string
-  accountId: BraveWallet.AccountId
-  txType: BraveWallet.TransactionType
-  sendOptions?: BraveWallet.SolanaSendTransactionOptions
-}
-
 export interface SendEthTransactionParams extends BaseEthTransactionParams {
   data?: number[]
 }