feat: decouple network fees from quote

packages/swapper/src/swappers/ArbitrumBridgeSwapper/endpoints.ts

@@ -137,8 +137,7 @@ export const arbitrumBridgeApi: SwapperApi = {
 
     const { receiveAddress } = tradeQuote
 
-    const assertion = await assertValidTrade({ buyAsset, sellAsset })
-    if (assertion.isErr()) throw new Error(assertion.unwrapErr().message)
+    await assertValidTrade({ buyAsset, sellAsset })
 
     const swap = await fetchArbitrumBridgeQuote({
       chainId,
@@ -177,6 +176,56 @@ export const arbitrumBridgeApi: SwapperApi = {
       ...feeData,
     }
   },
+  getEvmTransactionFees: async ({
+    chainId,
+    from,
+    stepIndex,
+    tradeQuote,
+    supportsEIP1559,
+    assertGetEvmChainAdapter,
+  }: GetUnsignedEvmTransactionArgs): Promise<string> => {
+    const step = getHopByIndex(tradeQuote, stepIndex)
+    if (!step) throw new Error(`No hop found for stepIndex ${stepIndex}`)
+
+    const { buyAsset, sellAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } = step
+
+    if (!isExecutableTradeQuote(tradeQuote)) throw new Error('Cannot execute a trade rate')
+
+    const { receiveAddress } = tradeQuote
+
+    const assertion = await assertValidTrade({ buyAsset, sellAsset })
+    if (assertion.isErr()) throw new Error(assertion.unwrapErr().message)
+
+    const swap = await fetchArbitrumBridgeQuote({
+      chainId,
+      supportsEIP1559,
+      buyAsset,
+      receiveAddress,
+      sellAmountIncludingProtocolFeesCryptoBaseUnit,
+      sellAsset,
+      sendAddress: from,
+      assertGetEvmChainAdapter,
+    })
+
+    const { request } = swap
+
+    if (!request) throw new Error('No request data found')
+
+    const {
+      txRequest: { data, value, to },
+    } = request
+
+    const { networkFeeCryptoBaseUnit } = await evm.getFees({
+      adapter: assertGetEvmChainAdapter(chainId),
+      data: data.toString(),
+      to,
+      value: value.toString(),
+      from,
+      supportsEIP1559,
+    })
+
+    return networkFeeCryptoBaseUnit
+  },
 
   checkTradeStatus: async ({
     txHash,

packages/swapper/src/swappers/ChainflipSwapper/endpoints.ts

@@ -2,7 +2,7 @@ import { fromAssetId, fromChainId, solAssetId } from '@shapeshiftoss/caip'
 import type { BuildSendApiTxInput, GetFeeDataInput } from '@shapeshiftoss/chain-adapters'
 import { FeeDataKey } from '@shapeshiftoss/chain-adapters'
 import type { BTCSignTx, SolanaSignTx } from '@shapeshiftoss/hdwallet-core'
-import type { EvmChainId, KnownChainIds } from '@shapeshiftoss/types'
+import type { EvmChainId, KnownChainIds, UtxoChainId } from '@shapeshiftoss/types'
 import { TxStatus } from '@shapeshiftoss/unchained-client'
 import type { InterpolationOptions } from 'node-polyglot'
 
@@ -95,6 +95,37 @@ export const chainflipApi: SwapperApi = {
       gasPrice: unsignedTxInput.gasPrice,
     }
   },
+  getEvmTransactionFees: async ({
+    from,
+    tradeQuote,
+    assertGetEvmChainAdapter,
+  }: GetUnsignedEvmTransactionArgs): Promise<string> => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw Error('Unable to execute trade')
+
+    const step = tradeQuote.steps[0]
+
+    if (!isExecutableTradeStep(step)) throw Error('Unable to execute step')
+    if (!step.chainflipSpecific?.chainflipDepositAddress) throw Error('Missing deposit address')
+    if (!step.chainflipSpecific?.chainflipSwapId) throw Error('Missing swap id')
+
+    const { assetReference } = fromAssetId(step.sellAsset.assetId)
+    const adapter = assertGetEvmChainAdapter(step.sellAsset.chainId)
+    const isTokenSend = isToken(step.sellAsset.assetId)
+    const getFeeDataInput: GetFeeDataInput<EvmChainId> = {
+      to: step.chainflipSpecific.chainflipDepositAddress,
+      value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+      chainSpecific: {
+        from,
+        contractAddress: isTokenSend ? assetReference : undefined,
+        data: undefined,
+      },
+      sendMax: false,
+    }
+    const { fast } = await adapter.getFeeData(getFeeDataInput)
+
+    return fast.txFee
+  },
+
   getUnsignedUtxoTransaction: ({
     tradeQuote,
     xpub,
@@ -128,6 +159,33 @@ export const chainflipApi: SwapperApi = {
       },
     })
   },
+  getUtxoTransactionFees: async ({
+    tradeQuote,
+    xpub,
+    assertGetUtxoChainAdapter,
+  }: GetUnsignedUtxoTransactionArgs): Promise<string> => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw Error('Unable to execute trade')
+    const step = tradeQuote.steps[0]
+    if (!isExecutableTradeStep(step)) throw Error('Unable to execute step')
+    if (!step.chainflipSpecific?.chainflipDepositAddress) throw Error('Missing deposit address')
+    if (!step.chainflipSpecific?.chainflipSwapId) throw Error('Missing swap id')
+
+    const adapter = assertGetUtxoChainAdapter(step.sellAsset.chainId)
+
+    const getFeeDataInput: GetFeeDataInput<UtxoChainId> = {
+      to: step.chainflipSpecific.chainflipDepositAddress,
+      value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+      chainSpecific: {
+        pubkey: xpub!,
+      },
+      sendMax: false,
+    }
+
+    const feeData = await adapter.getFeeData(getFeeDataInput)
+
+    return feeData.fast.txFee
+  },
+
   getUnsignedSolanaTransaction: async ({
     tradeQuote,
     from,
@@ -177,6 +235,43 @@ export const chainflipApi: SwapperApi = {
 
     return (await adapter.buildSendApiTransaction(buildSendTxInput)).txToSign
   },
+  getSolanaTransactionFees: async ({
+    tradeQuote,
+    from,
+    assertGetSolanaChainAdapter,
+  }: GetUnsignedSolanaTransactionArgs): Promise<string> => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw Error('Unable to execute trade')
+
+    const step = tradeQuote.steps[0]
+    if (!isExecutableTradeStep(step)) throw Error('Unable to execute step')
+    if (!step.chainflipSpecific?.chainflipDepositAddress) throw Error('Missing deposit address')
+    if (!step.chainflipSpecific?.chainflipSwapId) throw Error('Missing swap id')
+
+    tradeQuoteMetadata.set(tradeQuote.id, {
+      id: step.chainflipSpecific.chainflipSwapId,
+      address: step.chainflipSpecific?.chainflipDepositAddress,
+    })
+
+    const adapter = assertGetSolanaChainAdapter(step.sellAsset.chainId)
+
+    const contractAddress =
+      step.sellAsset.assetId === solAssetId
+        ? undefined
+        : fromAssetId(step.sellAsset.assetId).assetReference
+
+    const getFeeDataInput: GetFeeDataInput<KnownChainIds.SolanaMainnet> = {
+      to: step.chainflipSpecific.chainflipDepositAddress,
+      value: step.sellAmountIncludingProtocolFeesCryptoBaseUnit,
+      chainSpecific: {
+        from,
+        tokenId: contractAddress,
+      },
+    }
+
+    const { fast } = await adapter.getFeeData(getFeeDataInput)
+
+    return fast.txFee
+  },
 
   checkTradeStatus: async ({
     config,

packages/swapper/src/swappers/CowSwapper/endpoints.ts

@@ -144,6 +144,10 @@ export const cowApi: SwapperApi = {
 
     return { chainId, orderToSign }
   },
+  getEvmTransactionFees: (_args: GetUnsignedEvmMessageArgs): Promise<string> => {
+    // No transaction fees for CoW
+    return Promise.resolve('0')
+  },
 
   checkTradeStatus: async ({
     txHash, // TODO: this is not a tx hash, its an ID

packages/swapper/src/swappers/JupiterSwapper/endpoints.ts

@@ -1,6 +1,7 @@
-import type { BuildSendApiTxInput } from '@shapeshiftoss/chain-adapters'
+import type { BuildSendApiTxInput, GetFeeDataInput } from '@shapeshiftoss/chain-adapters'
 import type { SolanaSignTx } from '@shapeshiftoss/hdwallet-core'
 import type { KnownChainIds } from '@shapeshiftoss/types'
+import type { TransactionInstruction } from '@solana/web3.js'
 
 import type { GetUnsignedSolanaTransactionArgs, SwapperApi } from '../../types'
 import { isSolanaFeeData } from '../../types'
@@ -45,6 +46,54 @@ export const jupiterApi: SwapperApi = {
 
     return (await adapter.buildSendApiTransaction(buildSwapTxInput)).txToSign
   },
+  getSolanaTransactionFees: async ({
+    tradeQuote,
+    from,
+    assertGetSolanaChainAdapter,
+  }: GetUnsignedSolanaTransactionArgs): Promise<string> => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw Error('Unable to execute trade')
+
+    const step = tradeQuote.steps[0]
+
+    const adapter = assertGetSolanaChainAdapter(step.sellAsset.chainId)
+
+    if (!isExecutableTradeStep(step)) throw Error('Unable to execute step')
+
+    const solanaInstructions = step.jupiterTransactionMetadata?.instructions?.map(instruction =>
+      adapter.convertInstruction(instruction),
+    )
+
+    if (!isSolanaFeeData(step.feeData.chainSpecific)) throw Error('Unable to execute step')
+
+    const buildSwapTxInput: BuildSendApiTxInput<KnownChainIds.SolanaMainnet> = {
+      to: '',
+      from,
+      value: '0',
+      accountNumber: step.accountNumber,
+      chainSpecific: {
+        addressLookupTableAccounts: step.jupiterTransactionMetadata?.addressLookupTableAddresses,
+        instructions: solanaInstructions,
+        computeUnitLimit: step.feeData.chainSpecific?.computeUnits,
+        computeUnitPrice: step.feeData.chainSpecific?.priorityFee,
+      },
+    }
+
+    const { txToSign } = await adapter.buildSendApiTransaction(buildSwapTxInput)
+
+    const getFeeDataInput: GetFeeDataInput<KnownChainIds.SolanaMainnet> = {
+      to: txToSign.to,
+      value: txToSign.value,
+      chainSpecific: {
+        from,
+        addressLookupTableAccounts: step.jupiterTransactionMetadata?.addressLookupTableAddresses,
+        instructions: txToSign.instructions as TransactionInstruction[] | undefined,
+      },
+    }
+
+    const feeData = await adapter.getFeeData(getFeeDataInput)
+
+    return feeData.fast.txFee
+  },
 
   checkTradeStatus: checkSolanaSwapStatus,
 }

packages/swapper/src/swappers/LifiSwapper/endpoints.ts

@@ -174,6 +174,57 @@ export const lifiApi: SwapperApi = {
       ...{ ...feeData, gasLimit: gasLimit.toString() },
     }
   },
+  getEvmTransactionFees: async ({
+    chainId,
+    from,
+    stepIndex,
+    tradeQuote,
+    supportsEIP1559,
+    assertGetEvmChainAdapter,
+  }: GetUnsignedEvmTransactionArgs): Promise<string> => {
+    configureLiFi()
+    if (!isExecutableTradeQuote(tradeQuote)) throw Error('Unable to execute trade')
+
+    const lifiRoute = tradeQuoteMetadata.get(tradeQuote.id)
+
+    if (!lifiRoute) throw Error(`missing trade quote metadata for quoteId ${tradeQuote.id}`)
+
+    const lifiStep = lifiRoute.steps[stepIndex]
+
+    const { transactionRequest } = await getStepTransaction(lifiStep)
+
+    if (!transactionRequest) {
+      throw Error('undefined transactionRequest')
+    }
+
+    const { to, value, data, gasLimit } = transactionRequest
+
+    // checking values individually to keep type checker happy
+    if (to === undefined || value === undefined || data === undefined || gasLimit === undefined) {
+      const undefinedRequiredValues = [to, value, data, gasLimit].filter(
+        value => value === undefined,
+      )
+
+      throw Error('undefined required values in transactionRequest', {
+        cause: {
+          undefinedRequiredValues,
+        },
+      })
+    }
+
+    const { networkFeeCryptoBaseUnit } = await evm.getFees({
+      adapter: assertGetEvmChainAdapter(chainId),
+      data: data.toString(),
+      to,
+      // This looks odd but we need this, else unchained estimate calls will fail with:
+      // "invalid decimal value (argument=\"value\", value=\"0x0\", code=INVALID_ARGUMENT, version=bignumber/5.7.0)"
+      value: bn(value.toString()).toString(),
+      from,
+      supportsEIP1559,
+    })
+
+    return networkFeeCryptoBaseUnit
+  },
 
   checkTradeStatus: async ({
     quoteId,

packages/swapper/src/swappers/PortalsSwapper/endpoints.ts

@@ -49,6 +49,33 @@ export const portalsApi: SwapperApi = {
       return [tradeQuote]
     })
   },
+  getEvmTransactionFees: async ({
+    chainId,
+    from,
+    tradeQuote,
+    supportsEIP1559,
+    assertGetEvmChainAdapter,
+  }: GetUnsignedEvmTransactionArgs): Promise<string> => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw new Error('Unable to execute trade')
+
+    const { steps } = tradeQuote
+    const { portalsTransactionMetadata } = steps[0]
+
+    if (!portalsTransactionMetadata) throw new Error('Transaction metadata is required')
+
+    const { value, to, data } = portalsTransactionMetadata
+
+    const { networkFeeCryptoBaseUnit } = await evm.getFees({
+      adapter: assertGetEvmChainAdapter(chainId),
+      data,
+      to,
+      value,
+      from,
+      supportsEIP1559,
+    })
+
+    return networkFeeCryptoBaseUnit
+  },
   getUnsignedEvmTransaction: async ({
     chainId,
     from,