@exodus/ethereum-api 9.0.0-alpha.2 → 9.0.0

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

@@ -1,319 +1,125 @@
-/* eslint-disable  @exodus/export-default/last */
-
-import { getNonce, transactionExists } from '../eth-like-util'
-import {
-  calculateBumpedGasPrice,
-  isToken as checkIsToken,
-  normalizeTxId,
-} from '@exodus/ethereum-lib'
+import { parseUnsignedTx, updateNonce } from '@exodus/ethereum-lib'
+import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
-import getFeeInfo from './get-fee-info'
 
-const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
-  assert(assetClientInterface, 'assetClientInterface is required')
-  assert(createUnsignedTx, 'createUnsignedTx 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 })
-
-    // Using a default zero value to not break code relying on the `tx.feeAmount` property.
-    // For example, some exchange providers don't supply this.
-    if (!feeAmount) {
-      feeAmount = asset.baseAsset.currency.ZERO
-    }
+import { getOptimisticTxLogEffects } from '../tx-log/index.js'
+import { signTx } from '../tx-sign/index.js'
+import { ARBITRARY_ADDRESS } from '../tx-type/index.js'
+import { handleBroadcastError } from './broadcast-error-handler.js'
 
-    const fromAddress = await assetClientInterface.getReceiveAddress({
-      assetName: baseAsset.name,
-      walletAccount,
-    })
-
-    let nonceParam = _nonce
+const txSendFactory = ({ assetClientInterface, createTx }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(createTx, 'createTx is required')
 
-    const feeData = await assetClientInterface.getFeeData({
-      assetName: baseAsset.name,
-    })
+  return async ({ asset, walletAccount, unsignedTx: providedUnsignedTx, ...legacyParams }) => {
+    const baseAsset = asset.baseAsset
 
-    let eip1559Enabled = feeData.eip1559Enabled
+    const { unsignedTx } = providedUnsignedTx
+      ? { unsignedTx: providedUnsignedTx }
+      : await createTx({ asset, walletAccount, ...legacyParams })
 
-    // `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`)
-      }
+    const parsedTx = parseUnsignedTx({ asset, unsignedTx })
 
-      if (replacedTx.tokens.length > 0) {
-        const tokenTxSet = await assetClientInterface.getTxLog({
-          assetName: replacedTx.tokens[0],
-          walletAccount,
-        })
-        replacedTokenTx = tokenTxSet.get(bumpTxId)
+    // unknown data from buffer...
+    const to = parsedTx.to
+    const fromAddress = unsignedTx.txMeta.fromAddress
 
-        if (replacedTokenTx) {
-          asset = assets[replacedTx.tokens[0]]
-        }
-      }
+    assert(
+      to?.toLowerCase() !== ARBITRARY_ADDRESS,
+      `The receiving wallet address must not be ${ARBITRARY_ADDRESS}`
+    )
 
-      address = (replacedTokenTx || replacedTx).to
-      amount = (replacedTokenTx || replacedTx).coinAmount.negate()
-      feeOpts.gasLimit = replacedTx.data.gasLimit
-
-      const { gasPrice: currentGasPrice } = feeData
-      const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
-        baseAsset,
-        tx: replacedTx,
-        currentGasPrice,
-        eip1559Enabled,
-      })
-      feeOpts.gasPrice = bumpedGasPrice
-      feeOpts.tipGasPrice = bumpedTipGasPrice
-      eip1559Enabled = feeData.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,
+    // Are there any signin-level errors that should be caught here?
+    let { txId, rawTx } = await signTx({
       asset,
+      assetClientInterface,
+      unsignedTx,
       walletAccount,
-      toAddress: address,
-      amount,
-      nonce: nonceParam,
-      fromAddress,
-      eip1559Enabled,
-      customFee,
-      feeOpts,
-      txInput,
-      keepTxInput,
-      isSendAll,
-      isExchange,
-      createUnsignedTx,
-    }
-    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: tipGasPrice.toBaseString() }
-                  : Object.create(null)),
-              }
-            : { 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: tipGasPrice.toBaseString() } : {}),
-                }
-              : { gasLimit, replacedTxId: bumpTxId, nonce },
-          },
-        ],
+      const isBumpTx = !!unsignedTx.txMeta.bumpTxId
+      const { shouldRetry } = await handleBroadcastError(err, {
+        asset,
+        txId,
+        isHardware: !!unsignedTx.txMeta.isHardware,
+        hint: isBumpTx ? safeString`bumpTx` : safeString`broadcastTx`,
+        isBumpTx,
       })
-    }
-
-    return { txId }
-  }
-}
 
-const createTx = async ({
-  assetClientInterface,
-  asset,
-  walletAccount,
-  toAddress,
-  amount,
-  nonce,
-  txInput,
-  eip1559Enabled = true,
-  keepTxInput = false,
-  customFee: customGasPrice,
-  isSendAll,
-  isExchange,
-  fromAddress,
-  feeOpts,
-  createUnsignedTx,
-}) => {
-  const isToken = checkIsToken(asset)
+      if (shouldRetry) {
+        console.debug('trying to send again...') // inject logger factory from platform
 
-  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's try to fix the nonce issue
+        let newNonce = await baseAsset.getNonce({
+          asset,
+          fromAddress,
+          walletAccount,
+          forceFromNode: true,
+        })
 
-  let { gasLimit, gasPrice, tipGasPrice } = await getFeeInfo({
-    assetClientInterface,
-    asset,
-    fromAddress,
-    toAddress,
-    amount,
-    isExchange,
-    txInput,
-    feeOpts,
-  })
+        const triedNonce = parsedTx.nonce
+        // Defensive: avoid retrying the same nonce if node nonce is stale (non-replacement sends only).
+        if (!isBumpTx && typeof triedNonce === 'number') {
+          newNonce = Math.max(newNonce, triedNonce + 1)
+        }
 
-  if (eip1559Enabled) {
-    if (customGasPrice) {
-      gasPrice = customGasPrice // aka maxFeePerGas
+        // NOTE: An `unsignedTx.txData.transactionBuffer` may be optional
+        //       in `unsignedTx`, since a `providedUnsignedTx` may be
+        //       truthy but composed only of `legacyParams`:
+        //       https://github.com/ExodusMovement/assets/blob/4e3e873e3f5bfa8fce36f60be7d95a3dba9546e4/ethereum/ethereum-lib/src/unsigned-tx/parse-unsigned-tx.js#L104C5-L104C6
+        //
+        // TODO: should return an unsignedTx -> i.e. completely replicate the transaction
+        if (unsignedTx.txData.transactionBuffer) {
+          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
+          unsignedTx.txData.transactionBuffer = updateNonce({
+            chainId: baseAsset.chainId,
+            newNonce,
+            unsignedTx,
+          })
+        } else {
+          // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
+          unsignedTx.txData.nonce = newNonce
+        }
 
-      // We must ensure maxPriorityFeePerGas <= maxFeePerGas or our transaction library throws an error
-      // It's a bit counterintuitive  since maxPriorityFeePerGas should only contain the tip,
-      // so we should be subtracting the base gas price from the custom gas price to keep just the tip
-      // but the fee is also limited by our maxFeePerGas above, so that implicitly captures the max tip.
-      // Setting this tipGasPrice to undefined will result in a legacy transaction (not an EIP1559 anymore)
-      tipGasPrice = customGasPrice // aka maxPriorityFeePerGas
-    }
+        ;({ txId, rawTx } = await signTx({
+          asset,
+          assetClientInterface,
+          unsignedTx,
+          walletAccount,
+        }))
 
-    if (isSendAll && !isToken) {
-      // force consuming all gas
-      tipGasPrice = gasPrice
+        try {
+          await baseAsset.api.broadcastTx(rawTx.toString('hex'))
+        } catch (retryErr) {
+          await handleBroadcastError(retryErr, {
+            asset,
+            txId,
+            isHardware: false,
+            hint: safeString`retry:broadcastTx`,
+            isBumpTx: false, // retry path is only for non-bump anyway
+            isRetryNonceTx: true,
+          })
+        }
+      }
     }
 
-    // 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,
+    const { nonce, optimisticTxLogEffects } = await getOptimisticTxLogEffects({
+      asset,
+      assetClientInterface,
+      fromAddress,
+      txId,
+      unsignedTx,
       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,
-  })
+    for (const optimisticTxLogEffect of optimisticTxLogEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticTxLogEffect)
+    }
 
-  return {
-    txId: normalizeTxId(txId),
-    rawTx,
-    nonce,
-    gasLimit,
-    gasPrice,
-    tipGasPrice,
+    return { txId, nonce }
   }
 }
 

package/src/tx-sign/index.js

@@ -0,0 +1,17 @@
+import { normalizeTxId } from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+export const signTx = async ({ asset, assetClientInterface, unsignedTx, walletAccount }) => {
+  assert(asset, 'expected asset')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(unsignedTx, 'expected unsignedTx')
+  assert(walletAccount, 'expected walletAccount')
+
+  const { rawTx, txId } = await assetClientInterface.signTransaction({
+    assetName: asset.baseAsset.name,
+    unsignedTx,
+    walletAccount,
+  })
+
+  return { rawTx, txId: normalizeTxId(txId) }
+}