@exodus/ethereum-api 8.40.0 → 8.41.0-alpha.0

package/src/tx-send/tx-send.js

@@ -1,239 +1,96 @@
-/* eslint-disable  @exodus/export-default/last */
-
-import { calculateBumpedGasPrice, isEthereumLikeToken, normalizeTxId } from '@exodus/ethereum-lib'
+import { isEthereumLikeToken, normalizeTxId, parseUnsignedTx } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 import * as ErrorWrapper from '../error-wrapper.js'
-import { isContractAddressCached, transactionExists } from '../eth-like-util.js'
-import { getNftArguments } from '../nft-utils.js'
-import getFeeInfo from './get-fee-info.js'
+import { transactionExists } from '../eth-like-util.js'
+import { ARBITRARY_ADDRESS } from '../gas-estimation.js'
 import { resolveNonce } from './nonce-utils.js'
 
-// Exodus enforces a strict invariant that `sendAll` transactions
-// must not leave any dust in the sender's account. Currently, the
-// assets library has the expectation that the client frontend
-// should calculate the precise amount to send, but due to the
-// sheer amount of variables involved when resolving a `gasPrice`,
-// this is a significant undertaking.
-//
-// Therefore, although clients try their very best to calculate
-// the correct amount, in cases this fails we can fall back to
-// the implementation defined here with a warning.
-// eslint-disable-next-line camelcase
-export const HACK_maybeRefineSendAllAmount = async ({
-  amount: providedAmount,
-  asset,
-  assetClientInterface,
-  walletAccount,
-  gasLimit,
-  gasPrice,
-}) => {
-  try {
-    const { name: assetName, estimateL1DataFee } = asset
-
-    // HACK: For the interim, we won't attempt to
-    //       reconcile transaction dust on L2s due
-    //       to the nondeterminism about the calldata
-    //       fee.
-    if (typeof estimateL1DataFee === 'function') return null
-
-    const [txLog, accountState] = await Promise.all([
-      assetClientInterface.getTxLog({
-        assetName,
-        walletAccount,
-      }),
-      assetClientInterface.getAccountState({
-        assetName,
-        walletAccount,
-      }),
-    ])
-
-    const { spendable } = await asset.api.getBalances({ asset, txLog, accountState })
-    const maxGasCost = gasPrice.mul(gasLimit)
-
-    if (maxGasCost.gt(spendable)) throw new Error('transaction gas cost exceeds spendable balance')
-
-    const expectedSendAllAmount = spendable.sub(maxGasCost)
+const txSendFactory = ({ assetClientInterface, createTx }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(createTx, 'createTx is required')
 
-    // If the client attempted to send the correct
-    // amount, good job! You get a cookie!
-    if (providedAmount.equals(expectedSendAllAmount)) return null
+  async function signTx({ asset, unsignedTx, walletAccount }) {
+    const { rawTx, txId } = await assetClientInterface.signTransaction({
+      assetName: asset.baseAsset.name,
+      unsignedTx,
+      walletAccount,
+    })
 
-    // The client attempted to `sendAll` using the incorrect amount.
-    return expectedSendAllAmount
-  } catch (e) {
-    console.error('failed to refine send all amount', e)
-    return null
+    return { rawTx, txId: normalizeTxId(txId) }
   }
-}
-
-const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBalanceAndNonce }) => {
-  assert(assetClientInterface, 'assetClientInterface is required')
-  assert(createUnsignedTx, 'createUnsignedTx is required')
-  return async ({ asset, walletAccount, address, amount, feeData: maybeFeeData, options = {} }) => {
-    const {
-      nft,
-      bumpTxId,
-      nonce: providedNonce,
-      customFee,
-      keepTxInput,
-      isSendAll,
-      isHardware,
-      isPrivate,
-    } = options
-    let { txInput, feeAmount: providedFeeAmount } = options // avoid let!
-
-    const feeOpts = {
-      gasPrice: options.gasPrice,
-      tipGasPrice: options.tipGasPrice,
-      gasLimit: options.gasLimit,
-    }
 
+  return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
     const assetName = asset.name
     const baseAsset = asset.baseAsset
 
-    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
-
-    const feeData =
-      maybeFeeData ||
-      (await assetClientInterface.getFeeData({
-        assetName: baseAsset.name,
-      }))
+    const resolveUnsignedTx = async () => {
+      if (providedUnsignedTx) {
+        return { unsignedTx: providedUnsignedTx }
+      }
 
-    const { eip1559Enabled } = feeData
+      const feeData =
+        legacyParams.feeData ??
+        (await assetClientInterface.getFeeData({
+          assetName: baseAsset.name,
+        }))
 
-    const fromAddress = await assetClientInterface.getReceiveAddress({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
+      const fromAddress =
+        legacyParams.fromAddress ??
+        (await assetClientInterface.getReceiveAddress({
+          assetName: baseAsset.name,
+          walletAccount,
+        }))
 
-    let contractAddress
-    if (nft) {
-      const nftArguments = await getNftArguments({ asset, nft, fromAddress, toAddress: address })
-      contractAddress = nftArguments.contractAddress
-      feeOpts.gasLimit = nftArguments.gasLimit
-      txInput = nftArguments.txInput
-      amount = asset.baseAsset.currency.ZERO
+      return createTx({
+        asset,
+        walletAccount,
+        feeData,
+        fromAddress,
+        toAddress: legacyParams.address,
+        ...legacyParams,
+        ...legacyParams.options,
+      })
     }
 
-    let bumpNonce
+    const { unsignedTx } = await resolveUnsignedTx()
 
-    const baseAssetTxLog = await assetClientInterface.getTxLog({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
+    // this converts an transactionBuffer to values we can use when creating the tx logs
+    const parsedTx = parseUnsignedTx({ asset, unsignedTx })
 
-    // `replacedTx` is always an ETH/ETC transaction (not a token)
-    let replacedTx, replacedTokenTx
-    if (bumpTxId) {
-      replacedTx = baseAssetTxLog.get(bumpTxId)
+    // the txMeta.fee may include implicit l1 fees
+    const feeAmount = unsignedTx.txMeta.fee
+      ? asset.feeAsset.currency.parse(unsignedTx.txMeta.fee)
+      : parsedTx.fee
 
-      if (!replacedTx || !replacedTx.pending) {
-        throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
-      }
+    let nonce = parsedTx.nonce
 
-      if (replacedTx.tokens.length > 0) {
-        const [tokenAssetName] = replacedTx.tokens
-        const tokenTxSet = await assetClientInterface.getTxLog({
-          assetName: tokenAssetName,
-          walletAccount,
-        })
-        replacedTokenTx = tokenTxSet.get(bumpTxId)
-
-        if (replacedTokenTx) {
-          // Attempt to overwrite the asset to reflect the fact that
-          // we're performing a token transaction.
-          asset = assets[tokenAssetName]
-          if (!asset) {
-            console.warn(
-              `unable to find ${tokenAssetName} during token bump transaction: asset was not available in assetsForNetwork`
-            )
-          }
-        }
+    const tipGasPrice = parsedTx.tipGasPrice
+    const gasLimit = parsedTx.gasLimit
+    const amount = parsedTx.amount
+    const to = parsedTx.to
+    const eip1559Enabled = parsedTx.eip1559Enabled
 
-        // TODO: Should we `throw` if we can't find the asset?
-      }
-
-      address = (replacedTokenTx || replacedTx).to
-      amount = (replacedTokenTx || replacedTx).coinAmount.negate()
-      feeOpts.gasLimit = replacedTx.data.gasLimit
-
-      const { gasPrice: currentGasPrice, baseFeePerGas: currentBaseFee } = feeData
-      const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
-        baseAsset,
-        tx: replacedTx,
-        currentGasPrice,
-        currentBaseFee,
-        eip1559Enabled,
-      })
-      feeOpts.gasPrice = bumpedGasPrice
-      feeOpts.tipGasPrice = bumpedTipGasPrice
-      bumpNonce = replacedTx.data.nonce
-      txInput = replacedTokenTx ? null : replacedTx.data.data || '0x'
-      if (bumpNonce === undefined) {
-        throw new Error(`Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`)
-      }
-    }
+    // unknown data from buffer...
+    const selfSend = unsignedTx.txMeta.fromAddress === to
+    const replacedTxId = unsignedTx.txMeta.bumpTxId
 
-    // If we have evaluated a bump transaction and the `providedNonce` differs
-    // from the `bumpNonce`, we've encountered a conflict and cannot respect
-    // the caller's request.
-    if (
-      typeof bumpNonce === 'number' &&
-      typeof providedNonce === 'number' &&
-      bumpNonce !== providedNonce
+    assert(
+      to.toLowerCase() !== ARBITRARY_ADDRESS,
+      `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
     )
-      throw new ErrorWrapper.EthLikeError({
-        message: new Error('incorrect nonce for replacement transaction'),
-        reason: ErrorWrapper.reasons.bumpTxFailed,
-        hint: 'providedNonce',
-      })
-
-    // Choose a nonce that compensates for transctions which are currently
-    // in pending; for example, when we send transactions at low gas which
-    // will be stored by `geth` for execution at a later point in time.
-    //
-    // When we are not intentionally bumping a transaction, users are
-    // appending a new transaction to the chain - therefore we should
-    // be mindful of nonces belonging to us which are currently pending.
-    const resolvedNonce =
-      providedNonce ??
-      bumpNonce ??
-      (await resolveNonce({
-        asset,
-        fromAddress,
-        txLog: baseAssetTxLog,
-        // For assets where we'll fall back to querying the coin node, we
-        // search for pending transactions. For base assets with history,
-        // we'll fall back to the `TxLog` since this also has a knowledge
-        // of which transactions are currently in pending.
-        tag: 'pending',
-        useAbsoluteNonce: useAbsoluteBalanceAndNonce,
-      }))
 
-    const createTxParams = {
-      assetClientInterface,
+    let { txId, rawTx } = await signTx({
       asset,
+      unsignedTx,
       walletAccount,
-      toAddress: contractAddress || address,
-      amount,
-      nonce: resolvedNonce,
-      fromAddress,
-      customFee,
-      feeOpts,
-      txInput,
-      keepTxInput,
-      isSendAll,
-      createUnsignedTx,
-      feeData,
-      providedFeeAmount,
-    }
+    })
 
-    let { txId, rawTx, nonce, gasLimit, tipGasPrice, feeAmount } = await createTx(createTxParams)
+    const isPrivate = Boolean(legacyParams?.options?.isPrivate)
 
-    if (isPrivate && !baseAsset.api.features.transactionPrivacy)
+    if (isPrivate && typeof baseAsset.broadcastPrivateTx !== 'function')
       throw new Error(
-        `unable to send private transaction - transactionPrivacy is not enabled for ${baseAsset.name}`
+        `unable to send private transaction - private mempools are not enabled for ${baseAsset.name}`
       )
 
     const broadcastTx = isPrivate ? baseAsset.broadcastPrivateTx : baseAsset.api.broadcastTx
@@ -255,7 +112,7 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
           reason: ErrorWrapper.reasons.insufficientFunds,
           hint: 'broadcastTx',
         })
-      } else if (bumpTxId) {
+      } else if (unsignedTx.txMeta.bumpTxId) {
         throw new ErrorWrapper.EthLikeError({
           message: err.message,
           reason: ErrorWrapper.reasons.bumpTxFailed,
@@ -267,18 +124,16 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
           reason: ErrorWrapper.reasons.broadcastTxFailed,
           hint: 'otherErr:broadcastTx',
         })
-      } else if (nonceTooLowErr && !isHardware) {
+      } else if (nonceTooLowErr && !unsignedTx.txMeta.isHardware) {
         console.info('trying to send again...') // inject logger factory from platform
         // let's try to fix the nonce issue
-        nonce = await resolveNonce({
+        const newNonce = await resolveNonce({
           asset,
-          fromAddress,
-          providedNonce,
-          txLog: baseAssetTxLog,
           triedNonce: nonce,
           forceFromNode: true,
         })
-        ;({ txId, rawTx } = await createTx({ ...createTxParams, nonce }))
+        nonce = newNonce
+        ;({ txId, rawTx } = await signTx({ asset, unsignedTx, walletAccount }))
 
         try {
           await baseAsset.api.broadcastTx(rawTx.toString('hex'))
@@ -301,7 +156,18 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
       }
     }
 
-    const selfSend = fromAddress === address
+    const txData = eip1559Enabled
+      ? {
+          gasLimit,
+          replacedTxId,
+          nonce,
+          ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : Object.create(null)),
+        }
+      : {
+          gasLimit,
+          replacedTxId,
+          nonce,
+        }
 
     await assetClientInterface.updateTxLogAndNotify({
       assetName: asset.name,
@@ -315,21 +181,12 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
           feeAmount,
           feeCoinName: asset.feeAsset.name,
           selfSend,
-          to: address,
+          to,
           currencies: {
             [assetName]: asset.currency,
             [asset.feeAsset.name]: asset.feeAsset.currency,
           },
-          data: eip1559Enabled
-            ? {
-                gasLimit,
-                replacedTxId: bumpTxId,
-                nonce,
-                ...(tipGasPrice
-                  ? { tipGasPrice: tipGasPrice.toBaseString() }
-                  : Object.create(null)),
-              }
-            : { gasLimit, replacedTxId: bumpTxId, nonce },
+          data: txData,
         },
       ],
     })
@@ -347,20 +204,13 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
             feeAmount,
             feeCoinName: baseAsset.name,
             selfSend,
-            to: address,
+            to,
             token: asset.name,
             currencies: {
               [baseAsset.name]: baseAsset.currency,
               [asset.feeAsset.name]: asset.feeAsset.currency,
             },
-            data: eip1559Enabled
-              ? {
-                  gasLimit,
-                  replacedTxId: bumpTxId,
-                  nonce,
-                  ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : {}),
-                }
-              : { gasLimit, replacedTxId: bumpTxId, nonce },
+            data: txData,
           },
         ],
       })
@@ -370,146 +220,4 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx, useAbsoluteBala
   }
 }
 
-const createTx = async ({
-  assetClientInterface,
-  asset,
-  walletAccount,
-  toAddress,
-  amount,
-  nonce,
-  txInput,
-  keepTxInput = false,
-  customFee,
-  isSendAll,
-  fromAddress,
-  feeOpts,
-  createUnsignedTx,
-  feeData,
-  providedFeeAmount,
-}) => {
-  assert(
-    nonce !== undefined && typeof nonce === 'number',
-    'Nonce must be provided when creating a tx'
-  )
-  const isToken = isEthereumLikeToken(asset)
-
-  if (txInput && isToken && !keepTxInput)
-    throw new Error(`Additional data for Ethereum Token (${asset.name}) is not allowed`)
-
-  txInput =
-    isToken && !keepTxInput
-      ? asset.contract.transfer.build(toAddress.toLowerCase(), amount.toBaseString())
-      : txInput
-
-  let { gasLimit, gasPrice, tipGasPrice, eip1559Enabled } = await getFeeInfo({
-    assetClientInterface,
-    asset,
-    fromAddress,
-    toAddress,
-    amount,
-    txInput,
-    feeOpts,
-    feeData,
-    customFee,
-  })
-
-  const isContractToAddress = await isContractAddressCached({ asset, address: toAddress })
-
-  // HACK: We cannot ensure the no dust invariant for `isSendAll`
-  //       transactions to contract addresses, since we may be
-  //       performing a raw token transaction and the parameter
-  //       applies to the token and not the native amount.
-  //
-  //       Contracts have nondeterministic gas most of the time
-  //       versus estimations, anyway.
-  const isSendAllBaseAsset = isSendAll && !isToken && !isContractToAddress
-
-  // For native send all transactions, we have to make sure that
-  // the `tipGasPrice` is equal to the `gasPrice`, since this is
-  // effectively like saying that the `maxFeePerGas` is equal
-  // to the `maxPriorityFeePerGas`. We do this so that for a
-  // fixed gas cost transaction, no dust balance should remain,
-  // since any deviation in the underlying `baseFeePerGas` will
-  // result only affect the tip for the miner - no dust remains.
-  if (eip1559Enabled && isSendAllBaseAsset) {
-    // force consuming all gas
-    tipGasPrice = gasPrice
-  }
-
-  // HACK: If we are handling a send all transaction, we must ensure
-  //       the send all invariant is maintained before producing the
-  //       final transaction.
-  const maybeOverrideSendAllAmount =
-    isSendAllBaseAsset &&
-    (await HACK_maybeRefineSendAllAmount({
-      amount,
-      asset,
-      assetClientInterface,
-      walletAccount,
-      gasLimit,
-      gasPrice,
-    }))
-
-  if (maybeOverrideSendAllAmount) {
-    console.log(
-      `Attempted to execute a sendAll transaction with an amount of ${amount.toDefaultString({ unit: true })}, but this would fail to maintain the no dust invariant! Overriding with ${maybeOverrideSendAllAmount.toDefaultString({ unit: true })}.`
-    )
-    amount = maybeOverrideSendAllAmount
-  }
-
-  const unsignedTx = await createUnsignedTx({
-    asset,
-    walletAccount,
-    address: toAddress,
-    amount,
-    nonce,
-    txInput,
-    gasLimit,
-    gasPrice,
-    tipGasPrice,
-    fromAddress,
-    eip1559Enabled,
-  })
-
-  // TODO: move into createUnsignedTx()
-  if (keepTxInput && !isToken) {
-    unsignedTx.txData.to = toAddress
-  }
-
-  unsignedTx.txMeta.eip1559Enabled = eip1559Enabled
-
-  const resolveFee = async () => {
-    if (providedFeeAmount) {
-      return providedFeeAmount
-    }
-
-    const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
-      ? await asset.baseAsset.estimateL1DataFee({
-          unsignedTx,
-        })
-      : undefined
-
-    const l1DataFee = optimismL1DataFee
-      ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
-      : asset.baseAsset.currency.ZERO
-    return gasPrice.mul(gasLimit).add(l1DataFee)
-  }
-
-  const { txId, rawTx } = await assetClientInterface.signTransaction({
-    assetName: asset.baseAsset.name,
-    unsignedTx,
-    walletAccount,
-  })
-
-  return {
-    txId: normalizeTxId(txId),
-    rawTx,
-    nonce,
-    gasLimit,
-    gasPrice,
-    tipGasPrice,
-    feeAmount: await resolveFee(),
-  }
-}
-
 export default txSendFactory

package/src/tx-send/get-fee-info.js

@@ -1,58 +0,0 @@
-import { ensureSaneEip1559GasPriceForTipGasPrice } from '../fee-utils.js'
-import { fetchGasLimit } from '../gas-estimation.js'
-import { getFeeFactoryGasPrices } from '../get-fee.js'
-
-const getFeeInfo = async function getFeeInfo({
-  assetClientInterface,
-  asset,
-  fromAddress,
-  toAddress,
-  amount,
-  txInput,
-  feeOpts = {},
-  feeData,
-  customFee,
-}) {
-  // HACK: Previously, calls `getFeeInfo` were not provided a reference
-  //       to `feeData`. For backwards compatibility, we'll revert to
-  //       legacy behaviour.
-  // NOTE: This shouldn't actually be used outside of the `assets` repo;
-  //       this is done just for safety.
-  if (!feeData) {
-    console.warn('`getFeeInfo` was not explicitly passed a `feeData` object.')
-    const { name: assetName } = asset
-    feeData = await assetClientInterface.getFeeData({ assetName })
-  }
-
-  const {
-    gasPrice: gasPrice_,
-    feeData: { tipGasPrice: tipGasPrice_, eip1559Enabled },
-  } = getFeeFactoryGasPrices({ customFee, feeData })
-
-  const tipGasPrice = feeOpts.tipGasPrice || tipGasPrice_
-
-  const maybeGasPrice = feeOpts.gasPrice || gasPrice_
-
-  // HACK: If we've received an invalid combination of `tipGasPrice`
-  //       (maxPriorityFeePerGas) and `gasPrice` (maxFeePerGas), then
-  //       we must normalize these before returning.
-  const gasPrice = eip1559Enabled
-    ? ensureSaneEip1559GasPriceForTipGasPrice({ gasPrice: maybeGasPrice, tipGasPrice })
-    : maybeGasPrice
-
-  const gasLimit =
-    feeOpts.gasLimit ||
-    (await fetchGasLimit({
-      asset,
-      fromAddress,
-      toAddress,
-      amount,
-      txInput,
-      feeData,
-      throwOnError: false,
-    }))
-
-  return { gasPrice, gasLimit, tipGasPrice, eip1559Enabled }
-}
-
-export default getFeeInfo