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

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

@@ -1,92 +1,230 @@
-import { isEthereumLikeToken, normalizeTxId, parseUnsignedTx } from '@exodus/ethereum-lib'
+/* eslint-disable  @exodus/export-default/last */
+
+import { calculateBumpedGasPrice, isEthereumLikeToken, normalizeTxId } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
 import * as ErrorWrapper from '../error-wrapper.js'
-import { transactionExists } from '../eth-like-util.js'
-import { ARBITRARY_ADDRESS } from '../gas-estimation.js'
+import { isContractAddressCached, transactionExists } from '../eth-like-util.js'
+import { getNftArguments } from '../nft-utils.js'
+import getFeeInfo from './get-fee-info.js'
 import { resolveNonce } from './nonce-utils.js'
 
-const txSendFactory = ({ assetClientInterface, createTx }) => {
-  assert(assetClientInterface, 'assetClientInterface is required')
-  assert(createTx, 'createTx is required')
+// 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
 
-  async function signTx({ asset, unsignedTx, walletAccount }) {
-    const { rawTx, txId } = await assetClientInterface.signTransaction({
-      assetName: asset.baseAsset.name,
-      unsignedTx,
-      walletAccount,
-    })
+    // 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')
 
-    return { rawTx, txId: normalizeTxId(txId) }
+    const expectedSendAllAmount = spendable.sub(maxGasCost)
+
+    // If the client attempted to send the correct
+    // amount, good job! You get a cookie!
+    if (providedAmount.equals(expectedSendAllAmount)) return null
+
+    // The client attempted to `sendAll` using the incorrect amount.
+    return expectedSendAllAmount
+  } catch (e) {
+    console.error('failed to refine send all amount', e)
+    return null
   }
+}
+
+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 resolveUnsignedTx = async () => {
-      if (providedUnsignedTx) {
-        return { unsignedTx: providedUnsignedTx }
-      }
+    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
+
+    const feeData =
+      maybeFeeData ||
+      (await assetClientInterface.getFeeData({
+        assetName: baseAsset.name,
+      }))
 
-      const feeData =
-        legacyParams.feeData ??
-        (await assetClientInterface.getFeeData({
-          assetName: baseAsset.name,
-        }))
+    const { eip1559Enabled } = feeData
 
-      const fromAddress =
-        legacyParams.fromAddress ??
-        (await assetClientInterface.getReceiveAddress({
-          assetName: baseAsset.name,
-          walletAccount,
-        }))
+    const fromAddress = await assetClientInterface.getReceiveAddress({
+      assetName: baseAsset.name,
+      walletAccount,
+    })
 
-      return createTx({
-        asset,
-        walletAccount,
-        feeData,
-        fromAddress,
-        toAddress: legacyParams.address,
-        ...legacyParams,
-        ...legacyParams.options,
-      })
+    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
     }
 
-    const { unsignedTx } = await resolveUnsignedTx()
+    let bumpNonce
+
+    const baseAssetTxLog = await assetClientInterface.getTxLog({
+      assetName: baseAsset.name,
+      walletAccount,
+    })
+
+    // `replacedTx` is always an ETH/ETC transaction (not a token)
+    let replacedTx, replacedTokenTx
+    if (bumpTxId) {
+      replacedTx = baseAssetTxLog.get(bumpTxId)
 
-    // this converts an transactionBuffer to values we can use when creating the tx logs
-    const parsedTx = parseUnsignedTx({ asset, unsignedTx })
+      if (!replacedTx || !replacedTx.pending) {
+        throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
+      }
 
-    // the txMeta.fee may include implicit l1 fees
-    const feeAmount = unsignedTx.txMeta.fee
-      ? asset.feeAsset.currency.parse(unsignedTx.txMeta.fee)
-      : parsedTx.fee
+      if (replacedTx.tokens.length > 0) {
+        const [tokenAssetName] = replacedTx.tokens
+        const tokenTxSet = await assetClientInterface.getTxLog({
+          assetName: tokenAssetName,
+          walletAccount,
+        })
+        replacedTokenTx = tokenTxSet.get(bumpTxId)
 
-    let nonce = parsedTx.nonce
+        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`
+            )
+          }
+        }
+
+        // TODO: Should we `throw` if we can't find the asset?
+      }
 
-    const tipGasPrice = parsedTx.tipGasPrice
-    const gasLimit = parsedTx.gasLimit
-    const amount = parsedTx.amount
-    const to = parsedTx.to
-    const eip1559Enabled = parsedTx.eip1559Enabled
+      address = (replacedTokenTx || replacedTx).to
+      amount = (replacedTokenTx || replacedTx).coinAmount.negate()
+      feeOpts.gasLimit = replacedTx.data.gasLimit
 
-    // unknown data from buffer...
-    const selfSend = unsignedTx.txMeta.fromAddress === to
-    const replacedTxId = unsignedTx.txMeta.bumpTxId
+      const {
+        gasPrice: currentGasPrice,
+        baseFeePerGas: currentBaseFee,
+        tipGasPrice: currentTipGasPrice,
+      } = feeData
+      const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
+        baseAsset,
+        tx: replacedTx,
+        currentGasPrice,
+        currentBaseFee,
+        currentTipGasPrice,
+        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`)
+      }
+    }
 
-    assert(
-      to.toLowerCase() !== ARBITRARY_ADDRESS,
-      `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
+    // 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
     )
+      throw new ErrorWrapper.EthLikeError({
+        message: new Error('incorrect nonce for replacement transaction'),
+        reason: ErrorWrapper.reasons.bumpTxFailed,
+        hint: 'providedNonce',
+      })
 
-    let { txId, rawTx } = await signTx({
+    // 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 asset.baseAsset.getNonce({ asset, fromAddress, walletAccount }))
+
+    const createTxParams = {
+      assetClientInterface,
       asset,
-      unsignedTx,
       walletAccount,
-    })
+      toAddress: contractAddress || address,
+      amount,
+      nonce: resolvedNonce,
+      fromAddress,
+      customFee,
+      feeOpts,
+      txInput,
+      keepTxInput,
+      isSendAll,
+      createUnsignedTx,
+      feeData,
+      providedFeeAmount,
+    }
 
-    const isPrivate = Boolean(legacyParams?.options?.isPrivate)
+    let { txId, rawTx, nonce, gasLimit, tipGasPrice, feeAmount } = await createTx(createTxParams)
 
     if (isPrivate && typeof baseAsset.broadcastPrivateTx !== 'function')
       throw new Error(
@@ -112,7 +250,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
           reason: ErrorWrapper.reasons.insufficientFunds,
           hint: 'broadcastTx',
         })
-      } else if (unsignedTx.txMeta.bumpTxId) {
+      } else if (bumpTxId) {
         throw new ErrorWrapper.EthLikeError({
           message: err.message,
           reason: ErrorWrapper.reasons.bumpTxFailed,
@@ -124,16 +262,18 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
           reason: ErrorWrapper.reasons.broadcastTxFailed,
           hint: 'otherErr:broadcastTx',
         })
-      } else if (nonceTooLowErr && !unsignedTx.txMeta.isHardware) {
+      } else if (nonceTooLowErr && !isHardware) {
         console.info('trying to send again...') // inject logger factory from platform
         // let's try to fix the nonce issue
-        const newNonce = await resolveNonce({
+        nonce = await resolveNonce({
           asset,
+          fromAddress,
+          providedNonce,
+          txLog: baseAssetTxLog,
           triedNonce: nonce,
           forceFromNode: true,
         })
-        nonce = newNonce
-        ;({ txId, rawTx } = await signTx({ asset, unsignedTx, walletAccount }))
+        ;({ txId, rawTx } = await createTx({ ...createTxParams, nonce }))
 
         try {
           await baseAsset.api.broadcastTx(rawTx.toString('hex'))
@@ -156,18 +296,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
       }
     }
 
-    const txData = eip1559Enabled
-      ? {
-          gasLimit,
-          replacedTxId,
-          nonce,
-          ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : Object.create(null)),
-        }
-      : {
-          gasLimit,
-          replacedTxId,
-          nonce,
-        }
+    const selfSend = fromAddress === address
 
     await assetClientInterface.updateTxLogAndNotify({
       assetName: asset.name,
@@ -181,12 +310,21 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
           feeAmount,
           feeCoinName: asset.feeAsset.name,
           selfSend,
-          to,
+          to: address,
           currencies: {
             [assetName]: asset.currency,
             [asset.feeAsset.name]: asset.feeAsset.currency,
           },
-          data: txData,
+          data: eip1559Enabled
+            ? {
+                gasLimit,
+                replacedTxId: bumpTxId,
+                nonce,
+                ...(tipGasPrice
+                  ? { tipGasPrice: tipGasPrice.toBaseString() }
+                  : Object.create(null)),
+              }
+            : { gasLimit, replacedTxId: bumpTxId, nonce },
         },
       ],
     })
@@ -204,13 +342,20 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
             feeAmount,
             feeCoinName: baseAsset.name,
             selfSend,
-            to,
+            to: address,
             token: asset.name,
             currencies: {
               [baseAsset.name]: baseAsset.currency,
               [asset.feeAsset.name]: asset.feeAsset.currency,
             },
-            data: txData,
+            data: eip1559Enabled
+              ? {
+                  gasLimit,
+                  replacedTxId: bumpTxId,
+                  nonce,
+                  ...(tipGasPrice ? { tipGasPrice: tipGasPrice.toBaseString() } : {}),
+                }
+              : { gasLimit, replacedTxId: bumpTxId, nonce },
           },
         ],
       })
@@ -220,4 +365,146 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
   }
 }
 
+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