@exodus/ethereum-api 7.2.1 → 7.3.0

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

@@ -0,0 +1,300 @@
+/* eslint-disable  @exodus/export-default/last */
+
+import { getNonce, transactionExists } from '../eth-like-util'
+import {
+  createUnsignedTx,
+  calculateBumpedGasPrice,
+  isToken as checkIsToken,
+  normalizeTxId,
+} from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+import getFeeInfo from './get-fee-info'
+
+const txSendFactory = ({ assetClientInterface }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  return async ({
+    asset,
+    walletAccount,
+    amount,
+    address,
+    feeAmount,
+    shouldLog = true,
+    keepTxInput,
+    txInput,
+    nonce: _nonce,
+    bumpTxId,
+    customFee,
+    isSendAll,
+    isExchange,
+    feeOpts: feeOpts_ = {},
+  }) => {
+    const assetName = asset.name
+    const baseAsset = asset.baseAsset
+    const feeOpts = { ...feeOpts_ }
+    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
+    let eip1559Enabled = baseAsset.name === 'ethereum' // TODO: temp override, clean up use of eip1559Enabled flag and default to always true
+
+    const fromAddress = await assetClientInterface.getReceiveAddress({
+      assetName: baseAsset.name,
+      walletAccount,
+    })
+
+    let nonceParam = _nonce
+
+    // `replacedTx` is always an ETH/ETC transaction (not a token)
+    let replacedTx, replacedTokenTx
+    if (bumpTxId) {
+      const baseAssetTxLog = await assetClientInterface.getTxLog({
+        assetName: baseAsset.name,
+        walletAccount,
+      })
+      replacedTx = baseAssetTxLog.get(bumpTxId)
+      if (!replacedTx || !replacedTx.pending) {
+        throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
+      }
+
+      if (replacedTx.tokens.length > 0) {
+        const tokenTxSet = await assetClientInterface.getTxLog({
+          assetName: replacedTx.tokens[0],
+          walletAccount,
+        })
+        replacedTokenTx = tokenTxSet.get(bumpTxId)
+
+        if (replacedTokenTx) {
+          asset = assets[replacedTx.tokens[0]]
+        }
+      }
+
+      address = (replacedTokenTx || replacedTx).to
+      amount = (replacedTokenTx || replacedTx).coinAmount.negate()
+      feeOpts.gasLimit = replacedTx.data.gasLimit
+      const { gasPrice: currentGasPrice, eip1559Enabled: _eip1559Enabled } =
+        await assetClientInterface.getFeeData({
+          assetName,
+        })
+      const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
+        baseAsset,
+        tx: replacedTx,
+        currentGasPrice,
+        eip1559Enabled: _eip1559Enabled,
+      })
+      feeOpts.gasPrice = bumpedGasPrice
+      feeOpts.tipGasPrice = bumpedTipGasPrice
+      eip1559Enabled = _eip1559Enabled && feeOpts.tipGasPrice
+      nonceParam = replacedTx.data.nonce
+      txInput = replacedTokenTx ? null : replacedTx.data.data || '0x'
+      feeAmount = feeOpts.gasPrice.mul(feeOpts.gasLimit)
+      if (nonceParam === undefined) {
+        throw new Error(`Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`)
+      }
+    }
+
+    const createTxParams = {
+      assetClientInterface,
+      asset,
+      walletAccount,
+      toAddress: address,
+      amount,
+      nonce: nonceParam,
+      fromAddress,
+      eip1559Enabled,
+      customFee,
+      feeOpts,
+      txInput,
+      keepTxInput,
+      isSendAll,
+      isExchange,
+    }
+    let { txId, rawTx, nonce, gasLimit, tipGasPrice } = await createTx(createTxParams)
+
+    try {
+      await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+    } catch (err) {
+      const nonceTooLowErr = err.message.match(/nonce (is |)too low/i)
+      const txAlreadyExists = nonceTooLowErr
+        ? await transactionExists({ asset, txId })
+        : err.message.match(/already known/i)
+
+      if (txAlreadyExists) {
+        console.info('tx already broadcast') // inject logger factory from platform
+      } else if (bumpTxId || !nonceTooLowErr) {
+        throw err
+      } else if (nonceTooLowErr) {
+        console.info('trying to send again...') // inject logger factory from platform
+        // let's try to fix the nonce issue
+        nonce = await getNonce({ asset: baseAsset, address: fromAddress })
+        ;({ txId, rawTx } = await createTx({ ...createTxParams, nonce }))
+        await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+      }
+    }
+
+    const selfSend = fromAddress === address
+
+    await assetClientInterface.updateTxLogAndNotify({
+      assetName: asset.name,
+      walletAccount,
+      txs: [
+        {
+          txId,
+          confirmations: 0,
+          coinAmount: selfSend ? asset.currency.ZERO : amount.abs().negate(),
+          coinName: asset.name,
+          feeAmount,
+          feeCoinName: asset.feeAsset.name,
+          selfSend,
+          to: address,
+          currencies: {
+            [assetName]: asset.currency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
+          data: eip1559Enabled
+            ? {
+                gasLimit,
+                replacedTxId: bumpTxId,
+                nonce,
+                tipGasPrice: tipGasPrice.toBaseString(),
+              }
+            : { gasLimit, replacedTxId: bumpTxId, nonce },
+        },
+      ],
+    })
+
+    const isToken = checkIsToken(asset)
+    if (isToken) {
+      await assetClientInterface.updateTxLogAndNotify({
+        assetName: baseAsset.name,
+        walletAccount,
+        txs: [
+          {
+            txId,
+            coinAmount: baseAsset.currency.ZERO,
+            coinName: baseAsset.name,
+            feeAmount,
+            feeCoinName: baseAsset.name,
+            selfSend,
+            to: address,
+            token: asset.name,
+            currencies: {
+              [baseAsset.name]: baseAsset.currency,
+              [asset.feeAsset.name]: asset.feeAsset.currency,
+            },
+            data: eip1559Enabled
+              ? {
+                  gasLimit,
+                  replacedTxId: bumpTxId,
+                  nonce,
+                  tipGasPrice: tipGasPrice.toBaseString(),
+                }
+              : { gasLimit, replacedTxId: bumpTxId, nonce },
+          },
+        ],
+      })
+    }
+
+    return { txId }
+  }
+}
+
+const createTx = async ({
+  assetClientInterface,
+  asset,
+  walletAccount,
+  toAddress,
+  amount,
+  nonce,
+  txInput,
+  eip1559Enabled = true,
+  keepTxInput = false,
+  customFee: customGasPrice,
+  isSendAll,
+  isExchange,
+  fromAddress,
+  feeOpts,
+}) => {
+  const isToken = checkIsToken(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 } = await getFeeInfo({
+    assetClientInterface,
+    asset,
+    fromAddress,
+    toAddress,
+    amount,
+    isExchange,
+    txInput,
+    feeOpts,
+  })
+
+  if (eip1559Enabled) {
+    if (customGasPrice) {
+      gasPrice = customGasPrice
+    }
+
+    if (isSendAll && !isToken) {
+      // force consuming all gas
+      tipGasPrice = gasPrice
+    }
+
+    // gasLimit = customGasLimit
+  }
+
+  if (asset.baseAsset?.api?.hasFeature?.('noHistory')) {
+    nonce = await getNonce({ asset: asset.baseAsset, address: fromAddress })
+  }
+
+  if (nonce === undefined) {
+    // Calculate latest nonce from base asset's TX log
+    const baseAssetTxLog = await assetClientInterface.getTxLog({
+      assetName: asset.baseAsset.name,
+      walletAccount,
+    })
+    nonce = [...baseAssetTxLog]
+      .filter((tx) => tx.sent && !tx.dropped && tx.data.nonce != null)
+      .reduce((nonce, tx) => Math.max(tx.data.nonce + 1, nonce), 0)
+  }
+
+  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 { txId, rawTx } = await assetClientInterface.signTransaction({
+    assetName: asset.baseAsset.name,
+    unsignedTx,
+    walletAccount,
+  })
+
+  return {
+    txId: normalizeTxId(txId),
+    rawTx,
+    nonce,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+  }
+}
+
+export default txSendFactory