@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.1

package/src/create-asset.js

@@ -1,43 +1,57 @@
-import { connectAssetsList } from '@exodus/assets'
-import { pick } from '@exodus/basic-utils'
-import bip44Constants from '@exodus/bip44-constants/by-ticker'
-import { getBalancesFactory } from './get-balances'
-import { ClarityMonitor } from './tx-log/clarity-monitor'
-import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor'
-import { EthereumMonitor } from './tx-log/ethereum-monitor'
-
-import { createEvmServer } from './exodus-eth-server/server-factory'
-
+import { mapValues } from '@exodus/basic-utils'
+import { createConsoleLogger } from '@exodus/asset-lib'
+import { ASSET_FAMILY, connectAssetsList } from '@exodus/assets'
+import bip44Constants from '@exodus/bip44-constants/by-ticker.js'
 import {
   createEthereumLikeAccountState,
   createGetKeyIdentifier as defaultCreateGetKeyIdentifier,
+  createUnsignedTxFactory,
+  DEFAULT_FEE_MONITOR_INTERVAL,
   encodePrivate,
   encodePublicFactory,
+  getActivityTxs,
   hasChecksum,
-  signUnsignedTx,
-  signUnsignedTxWithSigner,
+  signHardwareFactory,
   signMessage,
   signMessageWithSigner,
-  signHardwareFactory,
-  DEFAULT_FEE_MONITOR_INTERVAL,
+  signUnsignedTx,
+  signUnsignedTxWithSigner,
   validateFactory,
-  createUnsignedTxFactory,
 } from '@exodus/ethereum-lib'
+import { toChecksumAddress } from '@exodus/ethereumjs/util'
 import assert from 'minimalistic-assert'
-import ms from 'ms'
-
-import { addressHasHistoryFactory } from './address-has-history'
-import { createTokenFactory } from './create-token-factory'
-import { getEffectiveGasPrice, getFeeFactory } from './get-fee'
-import { createEthereumHooks } from './hooks'
-import { createStakingApi } from './staking-api'
-import { txSendFactory } from './tx-send'
-import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor'
-import { createGetBalanceForAddress } from './get-balance-for-address'
-import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas'
-import { mapValues } from 'lodash'
-import { createWeb3API } from './web3'
-import getFeeAsyncFactory from './get-fee-async'
+
+import { addressHasHistoryFactory } from './address-has-history.js'
+import { createAssessTransaction } from './check-tx/create-assess-transaction.js'
+import { createCheckTx } from './check-tx/index.js'
+import {
+  createGetBlackListStatus,
+  createHistoryMonitorFactory,
+  createRpcRequestAccumulatorFactory,
+  createSecurityChecks,
+  createTransactionPrivacyFactory,
+  getNonceFactory,
+  resolveMonitorSettings,
+} from './create-asset-utils.js'
+import { createTokenFactory } from './create-token-factory.js'
+import { createCustomFeesApi } from './custom-fees.js'
+import { createEip7702Whitelist } from './eip7702-whitelist.js'
+import { getEIP7702Delegation, getIsNftContract } from './eth-like-util.js'
+import { createEvmServer } from './exodus-eth-server/index.js'
+import { createFeeData } from './fee-data/index.js'
+import { createGetBalanceForAddress } from './get-balance-for-address.js'
+import { getBalancesFactory } from './get-balances.js'
+import { getFeeFactory } from './get-fee.js'
+import { getHistoricalBalanceFactory } from './get-historical-balance.js'
+import { moveFundsFactory } from './move-funds.js'
+import { createEncodeMultisigContract } from './multisig-address.js'
+import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
+import { createSendValidations } from './send-validations.js'
+import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor.js'
+import { stakingApiFactory } from './staking/api/index.js'
+import { createTxFactory } from './tx-create.js'
+import { txSendFactory } from './tx-send/index.js'
+import { createWeb3API } from './web3/index.js'
 
 export const createAssetFactory = ({
   AccountState: CustomAccountState,
@@ -45,27 +59,44 @@ export const createAssetFactory = ({
   confirmationsNumber,
   customBip44,
   customCreateGetKeyIdentifier,
-  customTokens = true,
+  customTokens: defaultCustomTokens = true,
   erc20FuelBuffer,
-  feeData,
+  feeData: providedFeeData,
+  feeDataConfig,
   feeMonitorInterval,
   fuelThreshold,
   isMaxFeeAsset = false,
   isTestnet = false,
   l1GasOracleAddress, // l1 extra fee for base and optostakingConfiguration = {},
-  monitorInterval,
-  monitorType = 'magnifier',
-  nfts = false,
-  serverUrl,
-  stakingConfiguration = {},
+  monitorInterval: defaultMonitorInterval,
+  monitorType: defaultMonitorType,
+  multicall3Address: defaultMulticall3Address,
+  nfts: defaultNfts = false,
+  serverUrl: defaultServerUrl,
+  stakingConfiguration = Object.create(null),
+  stakingDependencies = Object.create(null),
   useEip1191ChainIdChecksum = false,
+  forceGasLimitEstimation = false,
+  rpcBalanceAssetNames = [],
+  blacklistChecks = [],
+  supportsCustomFees: defaultSupportsCustomFees = false,
+  useAbsoluteBalanceAndNonce = false,
+  delisted = false,
+  supportsTransactionPrivacy: defaultSupportsTransactionPrivacy,
+  wsGatewayUri: defaultWsGatewayUri,
+  eip7623Supported = false,
+  eip7702Supported,
+  transactionAssessment: defaultTransactionAssessment,
 }) => {
   assert(assetsList, 'assetsList is required')
-  assert(feeData, 'feeData is required')
-  assert(serverUrl, 'serverUrl is required')
+  assert(providedFeeData || feeDataConfig, 'feeData or feeDataConfig is required')
+  assert(defaultServerUrl, 'serverUrl is required')
+  assert(defaultMonitorType, 'monitorType is required')
   assert(confirmationsNumber, 'confirmationsNumber is required')
 
   const base = assetsList.find((asset) => asset.name === asset.baseAssetName)
+
+  const feeData = providedFeeData || createFeeData({ currency: base.currency, feeDataConfig })
   assert(base, 'base is required')
 
   const chainId = base.chainId
@@ -73,32 +104,66 @@ export const createAssetFactory = ({
 
   const createGetKeyIdentifier = customCreateGetKeyIdentifier || defaultCreateGetKeyIdentifier
 
+  const defaultConfig = {
+    allowMetaMaskCompat: false,
+    supportsStaking: false,
+    supportsCustomFees: defaultSupportsCustomFees,
+    nfts: defaultNfts,
+    customTokens: defaultCustomTokens,
+    supportsTransactionPrivacy: defaultSupportsTransactionPrivacy,
+    transactionAssessment: defaultTransactionAssessment,
+    multicall3Address: defaultMulticall3Address,
+  }
   return (
     {
       assetClientInterface,
-      config = {
-        allowMetaMaskCompat: false,
-        supportsStaking: false,
-      },
+      config = Object.create(null),
       overrideCallback = ({ asset }) => asset,
     } = Object.create(null)
   ) => {
     const assets = connectAssetsList(assetsList)
 
-    const { allowMetaMaskCompat, supportsStaking } = config
+    const configWithOverrides = { ...defaultConfig, ...config }
+
+    const {
+      allowMetaMaskCompat,
+      supportsStaking,
+      nfts,
+      customTokens,
+      supportsCustomFees,
+      useAbsoluteBalanceAndNonce: overrideUseAbsoluteBalanceAndNonce,
+      supportsTransactionPrivacy,
+      transactionAssessment,
+      multicall3Address,
+    } = configWithOverrides
 
     const asset = assets[base.name]
 
-    const server = createEvmServer({ assetName: asset.name, serverUrl, monitorType })
+    const { monitorType, serverUrl, monitorInterval } = resolveMonitorSettings({
+      asset,
+      configWithOverrides,
+      defaultMonitorInterval,
+      defaultMonitorType,
+      defaultServerUrl,
+      defaultWsGatewayUri,
+    })
 
-    const gasLimit = 21e3 // 21 KGas, enough only for sending ether to normal address
+    if (overrideUseAbsoluteBalanceAndNonce !== undefined) {
+      useAbsoluteBalanceAndNonce = overrideUseAbsoluteBalanceAndNonce
+    }
 
-    const contractGasLimit = 1e6 // used when estimateGas fail
+    const server = createEvmServer({
+      assetName: asset.name,
+      serverUrl,
+      monitorType,
+    })
 
     const address = {
       validate: validateFactory({ chainId, useEip1191ChainIdChecksum }),
       hasChecksum,
       isContract: server.isContract,
+      displayAddress: (addr) =>
+        useEip1191ChainIdChecksum ? toChecksumAddress(addr, chainId) : toChecksumAddress(addr),
     }
 
     const bip44 = customBip44 || bip44Constants['ETH']
@@ -108,36 +173,88 @@ export const createAssetFactory = ({
       encodePublic: encodePublicFactory({ chainId, useEip1191ChainIdChecksum }),
     }
 
-    const getBalances = getBalancesFactory({ monitorType })
+    // The Safe 4337 contract constants baked into the derivation are chainId 1 specific
+    const encodeMultisigContract =
+      chainId === 1
+        ? createEncodeMultisigContract({ chainId, encodePublic: keys.encodePublic })
+        : undefined
+
+    const getBalances = getBalancesFactory({
+      monitorType,
+      useAbsoluteBalance: useAbsoluteBalanceAndNonce,
+      rpcBalanceAssetNames,
+    })
+
+    const historicalBalanceSupported = monitorType !== 'no-history'
+    const getHistoricalBalance = getHistoricalBalanceFactory({
+      assetClientInterface,
+      getBalances,
+    })
+
+    const createRpcRequestAccumulator = createRpcRequestAccumulatorFactory({
+      multicall3Address,
+    })
 
     const { createToken, getTokens } = createTokenFactory(
-      { address, bip44, keys, getBalances },
+      {
+        address,
+        bip44,
+        keys,
+        getBalances,
+        getHistoricalBalance,
+        historicalBalance: historicalBalanceSupported,
+        assetClientInterface,
+        server,
+        stakingConfiguration,
+        stakingDependencies,
+        createRpcRequestAccumulator,
+      },
       assets
     )
 
     const addressHasHistory = addressHasHistoryFactory({ server })
 
-    const feeMonitor = monitorType === 'no-history'
+    const isWebSocket = monitorType !== 'no-history'
+
+    const resolvedFeeMonitorInterval =
+      config.feeMonitorInterval ||
+      feeMonitorInterval ||
+      (isWebSocket ? null : DEFAULT_FEE_MONITOR_INTERVAL) // null means do not start the timer
 
     const createFeeMonitor = serverBasedFeeMonitorFactoryFactory({
-      assetName: base.name,
-      interval: config.feeMonitorInterval || feeMonitorInterval || DEFAULT_FEE_MONITOR_INTERVAL,
-      eip1559Enabled: feeData.eip1559Enabled, // this is not updated via remote config. Should it be?
+      asset: base,
+      interval: resolvedFeeMonitorInterval,
+      aci: assetClientInterface,
       server,
     })
 
+    const { broadcastPrivateBundle, broadcastPrivateTx, sendPrivateTx, sendPrivateBundle } =
+      createTransactionPrivacyFactory({
+        assetClientInterface,
+        assetName: asset.name,
+        server,
+        supportsTransactionPrivacy,
+      })
+
     const features = {
       accountState: true,
       customTokens,
-      feeMonitor,
+      family: ASSET_FAMILY.EVM,
+      feeMonitor: true,
       feesApi: true,
+      historicalBalance: historicalBalanceSupported,
       isMaxFeeAsset,
       isTestnet,
+      moveFunds: true,
+      multisig: Boolean(encodeMultisigContract),
       nfts,
       noHistory: monitorType === 'no-history',
       signWithSigner: true,
       signMessageWithSigner: true,
+      supportsCustomFees,
+      supportsTransactionPrivacy: Boolean(supportsTransactionPrivacy),
       ...(supportsStaking && { staking: {} }),
+      ...(delisted && { delisted }),
     }
 
     const stakingAssetNames = Object.keys(stakingConfiguration)
@@ -145,6 +262,8 @@ export const createAssetFactory = ({
     const extraData =
       stakingAssetNames.length > 0
         ? {
+            // Persist ownership independently of host annotations and balances.
+            stakingSnapshotOwners: {},
             staking: mapValues(
               stakingConfiguration,
               (assetStakinConfiguration) => assetStakinConfiguration.accountStateExtraData
@@ -152,76 +271,102 @@ export const createAssetFactory = ({
           }
         : undefined
 
+    const getBlackListStatus = createGetBlackListStatus({ server, address, blacklistChecks })
+
+    // eip7702Supported is the chain-level feature flag ([] when supported).
+    // The whitelist itself is populated from remote config through the
+    // history monitor's setServer.
+    const eip7702Whitelist = createEip7702Whitelist(eip7702Supported)
+
     const accountStateClass =
       CustomAccountState || createEthereumLikeAccountState({ asset: base, assets, extraData })
 
-    const createHistoryMonitor = (args) => {
-      let monitor
-      switch (monitorType) {
-        case 'clarity':
-          monitor = new ClarityMonitor({ interval: ms(monitorInterval || '5m'), server, ...args })
-          break
-        case 'no-history':
-          monitor = new EthereumNoHistoryMonitor({
-            interval: ms(monitorInterval || '15s'),
-            server,
-            ...args,
-          })
-          break
-        case 'magnifier':
-          monitor = new EthereumMonitor({ interval: ms(monitorInterval || '15s'), server, ...args })
-          break
-        default:
-          throw new Error(`Monitor type ${monitorType} of evm asset ${asset.name} is unknown`)
-      }
-
-      if (stakingAssetNames.length > 0) {
-        const afterTickHook = createEthereumHooks({
-          assetClientInterface,
-          assetName: asset.name,
-          stakingAssetNames,
-          server,
-        })['after-tick']
-        monitor.addHook('after-tick', afterTickHook)
-      }
-
-      return monitor
-    }
+    const createHistoryMonitor = createHistoryMonitorFactory({
+      assetName: asset.name,
+      assetClientInterface,
+      monitorInterval,
+      monitorType,
+      server,
+      stakingConfiguration,
+      rpcBalanceAssetNames,
+      eip7702Whitelist,
+      getBlackListStatus,
+    })
 
     const defaultAddressPath = 'm/0/0'
 
     const createUnsignedTx = createUnsignedTxFactory({ chainId })
 
+    const createTx = createTxFactory({
+      chainId,
+      assetClientInterface,
+      useAbsoluteNonce: useAbsoluteBalanceAndNonce,
+    })
+
     const sendTx = txSendFactory({
       assetClientInterface,
-      createUnsignedTx,
+      createTx,
     })
 
+    const getFeeAsync = async (...args) => {
+      const { unsignedTx, amount, ...rest } = await createTx(...args)
+      return rest
+    }
+
     const estimateL1DataFee = l1GasOracleAddress
       ? estimateL1DataFeeFactory({ l1GasOracleAddress, server })
       : undefined
 
-    const originalGetFee = getFeeFactory({ gasLimit })
+    const originalGetFee = getFeeFactory()
 
     const getFee = l1GasOracleAddress
       ? getL1GetFeeFactory({ asset, originalGetFee })
       : originalGetFee
 
+    const { getNonce } = getNonceFactory({ assetClientInterface, useAbsoluteBalanceAndNonce })
+
+    const securityChecks = createSecurityChecks({ eip7702Whitelist })
+
+    const web3 = createWeb3API({ asset })
+
+    let checkTx
+    let sendValidations = []
+    if (transactionAssessment?.enabled) {
+      checkTx = createCheckTx({
+        makeApiCall: createAssessTransaction({ apiUrl: transactionAssessment.apiUrl }),
+        logger: createConsoleLogger('@exodus/ethereum-api:check-tx'),
+      })
+      sendValidations = createSendValidations({ assetClientInterface, checkTx })
+    }
+
+    const moveFunds = moveFundsFactory({
+      baseAssetName: asset.name,
+      assetClientInterface,
+      createTx,
+      server,
+    })
+
     const api = {
       addressHasHistory,
       broadcastTx: (...args) => server.sendRawTransaction(...args),
       createAccountState: () => accountStateClass,
+      securityChecks,
       createFeeMonitor,
       createHistoryMonitor,
       createToken,
-      createUnsignedTx,
+      createTx,
+      createUnsignedTx, // @deprecated use createTx instead
+      customFees: createCustomFeesApi({ baseAsset: asset }),
       defaultAddressPath,
       features,
+      getActivityTxs,
       getBalances,
+      ...(features.historicalBalance && { getHistoricalBalance }),
       getBalanceForAddress: createGetBalanceForAddress({ asset, server }),
+      ...(getBlackListStatus && { getBlackListStatus }),
       getConfirmationsNumber: () => confirmationsNumber,
       getDefaultAddressPath: () => defaultAddressPath,
-      getFeeAsync: getFeeAsyncFactory({ assetClientInterface, gasLimit, createUnsignedTx }),
+      getFeeAsync, // createTx alias, remove me when possible
       getFee,
       getFeeData: () => feeData,
       getKeyIdentifier: createGetKeyIdentifier({
@@ -230,38 +375,69 @@ export const createAssetFactory = ({
         assetName: asset.name,
       }),
       getSupportedPurposes: () => [44],
+      ...(sendValidations.length > 0 && { getSendValidations: () => sendValidations }),
       getTokens,
       hasFeature: (feature) => !!features[feature], // @deprecated use api.features instead
+      moveFunds,
+      privateKeyEncodingDefinition: { encoding: 'hex' },
       sendTx,
       signTx: ({ unsignedTx, privateKey, signer }) =>
         signer
           ? signUnsignedTxWithSigner(unsignedTx, signer)
           : signUnsignedTx(unsignedTx, privateKey),
-      signHardware: signHardwareFactory({ baseAssetName: asset.name }),
+      signHardware: signHardwareFactory({
+        baseAssetName: asset.name,
+        getIsNft: ({ address }) => getIsNftContract({ server, address }),
+      }),
       signMessage: ({ message, privateKey, signer }) =>
         signer ? signMessageWithSigner({ message, signer }) : signMessage({ privateKey, message }),
-      ...(supportsStaking && { staking: createStakingApi({ network: asset.name }) }),
+      ...(checkTx && { checkTx }),
+      ...(supportsStaking &&
+        stakingDependencies[asset.name] && {
+          staking: stakingApiFactory({
+            assetName: asset.name,
+            currency: asset.currency,
+            assetClientInterface,
+            server,
+            stakingConfiguration: stakingConfiguration[asset.name],
+            stakingDependencies: stakingDependencies[asset.name],
+          }),
+        }),
       validateAssetId: address.validate,
-      web3: createWeb3API({ asset }),
+      web3,
     }
 
     const fullAsset = {
       ...asset,
-      ...pick(config, ['accountReserve']),
-      gasLimit,
-      contractGasLimit,
       bip44,
       keys,
       address,
       api,
       chainId,
+      ...(encodeMultisigContract && { encodeMultisigContract }),
       monitorType,
       estimateL1DataFee,
+      forceGasLimitEstimation,
+      eip7623Supported,
+      // Stable array reference kept up to date with remote config by the
+      // history monitor's setServer.
+      eip7702Supported: eip7702Whitelist.get(),
+      getEIP7702Delegation: (addr) => getEIP7702Delegation({ address: addr, server }),
+      getNonce,
       server,
       ...(erc20FuelBuffer && { erc20FuelBuffer }),
       ...(fuelThreshold && { fuelThreshold: asset.currency.defaultUnit(fuelThreshold) }),
-      getEffectiveGasPrice,
+      broadcastPrivateBundle,
+      broadcastPrivateTx,
+      createRpcRequestAccumulator,
+      sendPrivateTx,
+      sendPrivateBundle,
     }
-    return overrideCallback({ asset: fullAsset })
+    return overrideCallback({
+      asset: fullAsset,
+      stakingConfiguration,
+      assetClientInterface,
+      monitorInterval,
+    })
   }
 }

package/src/create-token-factory.js

@@ -1,10 +1,16 @@
-import { isPolygonClaimUndelegate, isPolygonDelegate, isPolygonUndelegate } from './staking/matic'
+import { ASSET_FAMILY } from '@exodus/assets'
 import { createContract } from '@exodus/ethereum-lib'
-
-import { createStakingApi } from './staking-api'
 import assert from 'minimalistic-assert'
 
+import { stakingApiFactory } from './staking/api/index.js'
+import {
+  isPolygonClaimUndelegate,
+  isPolygonDelegate,
+  isPolygonUndelegate,
+} from './staking/matic/index.js'
+
 const defaultTokenFeatures = {
+  family: ASSET_FAMILY.EVM,
   isMaxFeeAsset: true,
 }
 
@@ -29,31 +35,55 @@ const getPolygonActivityTxs = ({ txs }) =>
 const getActivityTxs = ({ txs }) => txs.filter((tx) => !smallbalanceTx(tx))
 
 const getCreateBaseToken =
-  ({ getBalances, ...props }) =>
+  ({
+    getBalances,
+    getHistoricalBalance,
+    historicalBalance,
+    assetClientInterface,
+    server,
+    stakingConfiguration = Object.create(null),
+    stakingDependencies = Object.create(null),
+    createRpcRequestAccumulator,
+    ...props
+  }) =>
   ({ name, contract, features, ...tokenDef }) => {
     assert(getBalances, 'getBalances is required')
     const tokenSpecificFeatures = name === 'polygon' ? { staking: {} } : {}
-    const tokenSpecificApiFunctions =
-      name === 'polygon' ? { staking: createStakingApi({ network: name }) } : {}
 
     const tokenFeatures = { ...defaultTokenFeatures, ...features, ...tokenSpecificFeatures }
-    return {
+    const baseApi = {
+      getActivityTxs: name === 'polygon' ? getPolygonActivityTxs : getActivityTxs,
+      features: tokenFeatures,
+      hasFeature: (feature) => !!tokenFeatures[feature], // @deprecated use api.features instead
+      getBalances,
+      ...(historicalBalance && { getHistoricalBalance }),
+      getTxLogFilter: name === 'polygon' ? getPolygonTxLogFilter : getTxLogFilter,
+    }
+
+    const tokenAsset = {
       ...tokenDef,
       addresses: contract,
-      assetId: contract.current,
+      assetId: contract.current.toLowerCase(),
       contract: createContract(contract.current, name),
       gasLimit: 120_000,
       name,
-      api: {
-        getActivityTxs: name === 'polygon' ? getPolygonActivityTxs : getActivityTxs,
-        features: tokenFeatures,
-        hasFeature: (feature) => !!tokenFeatures[feature], // @deprecated use api.features instead
-        getBalances,
-        getTxLogFilter: name === 'polygon' ? getPolygonTxLogFilter : getTxLogFilter,
-        ...tokenSpecificApiFunctions,
-      },
-      ...props, // override props above, add new props
+      api: baseApi,
+      ...props,
     }
+
+    if (name === 'polygon' && stakingDependencies[name]) {
+      baseApi.staking = stakingApiFactory({
+        assetName: tokenAsset.name,
+        currency: tokenAsset.currency,
+        assetClientInterface,
+        server,
+        stakingConfiguration: stakingConfiguration[name],
+        stakingDependencies: stakingDependencies[name],
+        createRpcRequestAccumulator,
+      })
+    }
+
+    return tokenAsset
   }
 
 export const createTokenFactory = (props, assets) => {

package/src/custom-fees.js

@@ -0,0 +1,57 @@
+import NumberUnit from '@exodus/currency'
+
+import { resolveGasPrice } from './fee-utils.js'
+
+const calculateMinCustomFee = ({ feeData }) => {
+  const { eip1559Enabled, baseFeePerGas, gasPriceMinimumRate } = feeData
+
+  // On `eip1559Enabled` networks, the `baseFeePerGas` is
+  // the minimum a transaction should be sent using, else
+  // get rejected by the RPC.
+  if (eip1559Enabled && baseFeePerGas) return baseFeePerGas.mul(Math.max(gasPriceMinimumRate, 1))
+
+  // On legacy networks, senders are permitted to send
+  // transactions below the `baseFeePerGas` (since these
+  // would not be rejected by the RPC - in fact, it was
+  // even possible to mine transactions with a `gasPrice`
+  // of `0`!).
+  return resolveGasPrice({ feeData }).mul(gasPriceMinimumRate)
+}
+
+const calculateRecommendedCustomFee = ({ min, feeData }) => {
+  const recommended = resolveGasPrice({ feeData })
+  // The `recommended` fee must be at least the `min`.
+  return recommended.gt(min) ? recommended : min
+}
+
+const calculateMaxCustomFee = ({ feeData, recommended }) => {
+  const { gasPriceMinimumRate, gasPriceMaximumRate } = feeData
+
+  const maxGasPrice = resolveGasPrice({ feeData }).mul(
+    Math.max(gasPriceMaximumRate, gasPriceMinimumRate)
+  )
+
+  // When calculating the `max` custom fee, the returned fee
+  // must be at least the `recommended` price.
+  return recommended.gt(maxGasPrice) ? recommended : maxGasPrice
+}
+
+export const createCustomFeesApi = ({ baseAsset }) => {
+  const Gwei = baseAsset.currency.units.Gwei
+  return {
+    getRecommendedMinMaxFeeUnitPrices: ({ feeData }) => {
+      const min = calculateMinCustomFee({ feeData })
+      const recommended = calculateRecommendedCustomFee({ feeData, min })
+      const max = calculateMaxCustomFee({ feeData, recommended })
+      return {
+        recommended: recommended.toNumber(Gwei),
+        min: min.toNumber(Gwei),
+        max: max.toNumber(Gwei),
+      }
+    },
+    unit: 'gwei/gas',
+    feeUnitPriceToNumber: (feeNumberUnit) => feeNumberUnit.toNumber(Gwei),
+    numberToFeeUnitPrice: (value) => NumberUnit.create(value, Gwei),
+    isEnabled: ({ feeData }) => Boolean(feeData.rbfEnabled),
+  }
+}