@exodus/ethereum-api 8.34.5 → 8.34.7

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

@@ -29,7 +29,13 @@ export const HACK_maybeRefineSendAllAmount = async ({
   gasPrice,
 }) => {
   try {
-    const { name: assetName } = asset
+    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({
@@ -64,7 +70,7 @@ export const HACK_maybeRefineSendAllAmount = async ({
 const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(createUnsignedTx, 'createUnsignedTx is required')
-  return async ({ asset, walletAccount, address, amount, options = {} }) => {
+  return async ({ asset, walletAccount, address, amount, feeData: maybeFeeData, options = {} }) => {
     const {
       nft,
       bumpTxId,
@@ -87,13 +93,18 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
 
     const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
 
+    const feeData =
+      maybeFeeData ||
+      (await assetClientInterface.getFeeData({
+        assetName: baseAsset.name,
+      }))
+
+    const { eip1559Enabled } = feeData
+
     const fromAddress = await assetClientInterface.getReceiveAddress({
       assetName: baseAsset.name,
       walletAccount,
     })
-    const feeData = await assetClientInterface.getFeeData({
-      assetName: baseAsset.name,
-    })
 
     let contractAddress
     if (nft) {
@@ -106,8 +117,6 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
 
     let bumpNonce
 
-    let eip1559Enabled = feeData.eip1559Enabled
-
     const baseAssetTxLog = await assetClientInterface.getTxLog({
       assetName: baseAsset.name,
       walletAccount,
@@ -117,36 +126,47 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
     let replacedTx, replacedTokenTx
     if (bumpTxId) {
       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 [tokenAssetName] = replacedTx.tokens
         const tokenTxSet = await assetClientInterface.getTxLog({
-          assetName: replacedTx.tokens[0],
+          assetName: tokenAssetName,
           walletAccount,
         })
         replacedTokenTx = tokenTxSet.get(bumpTxId)
 
         if (replacedTokenTx) {
-          asset = assets[replacedTx.tokens[0]]
+          // 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?
       }
 
       address = (replacedTokenTx || replacedTx).to
       amount = (replacedTokenTx || replacedTx).coinAmount.negate()
       feeOpts.gasLimit = replacedTx.data.gasLimit
 
-      const { gasPrice: currentGasPrice } = feeData
+      const { gasPrice: currentGasPrice, baseFeePerGas: currentBaseFee } = feeData
       const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
         baseAsset,
         tx: replacedTx,
         currentGasPrice,
+        currentBaseFee,
         eip1559Enabled,
       })
       feeOpts.gasPrice = bumpedGasPrice
       feeOpts.tipGasPrice = bumpedTipGasPrice
-      eip1559Enabled = feeData.eip1559Enabled && feeOpts.tipGasPrice
       bumpNonce = replacedTx.data.nonce
       txInput = replacedTokenTx ? null : replacedTx.data.data || '0x'
       if (bumpNonce === undefined) {
@@ -154,9 +174,40 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
       }
     }
 
+    // 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',
+      })
+
+    // 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, providedNonce, txLog: baseAssetTxLog }))
+      (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',
+      }))
 
     const createTxParams = {
       assetClientInterface,
@@ -166,14 +217,15 @@ const txSendFactory = ({ assetClientInterface, createUnsignedTx }) => {
       amount,
       nonce: resolvedNonce,
       fromAddress,
-      eip1559Enabled,
       customFee,
       feeOpts,
       txInput,
       keepTxInput,
       isSendAll,
       createUnsignedTx,
+      feeData,
     }
+
     let { txId, rawTx, nonce, gasLimit, tipGasPrice, gasPrice } = await createTx(createTxParams)
 
     const feeAmount = gasPrice.mul(gasLimit)
@@ -318,13 +370,13 @@ const createTx = async ({
   amount,
   nonce,
   txInput,
-  eip1559Enabled = true,
   keepTxInput = false,
-  customFee: customGasPrice,
+  customFee,
   isSendAll,
   fromAddress,
   feeOpts,
   createUnsignedTx,
+  feeData,
 }) => {
   assert(
     nonce !== undefined && typeof nonce === 'number',
@@ -340,7 +392,7 @@ const createTx = async ({
       ? asset.contract.transfer.build(toAddress.toLowerCase(), amount.toBaseString())
       : txInput
 
-  let { gasLimit, gasPrice, tipGasPrice } = await getFeeInfo({
+  let { gasLimit, gasPrice, tipGasPrice, eip1559Enabled } = await getFeeInfo({
     assetClientInterface,
     asset,
     fromAddress,
@@ -348,6 +400,8 @@ const createTx = async ({
     amount,
     txInput,
     feeOpts,
+    feeData,
+    customFee,
   })
 
   const isContractToAddress = await isContractAddressCached({ asset, address: toAddress })
@@ -361,22 +415,16 @@ const createTx = async ({
   //       versus estimations, anyway.
   const isSendAllBaseAsset = isSendAll && !isToken && !isContractToAddress
 
-  if (eip1559Enabled) {
-    if (customGasPrice) {
-      gasPrice = customGasPrice // aka maxFeePerGas
-
-      // 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
-    }
-
-    if (isSendAllBaseAsset) {
-      // force consuming all gas
-      tipGasPrice = gasPrice
-    }
+  // 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

package/src/websocket/index.android.js

@@ -1,2 +0,0 @@
-/* global WebSocket */
-export default WebSocket

package/src/websocket/index.ios.js

@@ -1,2 +0,0 @@
-/* global WebSocket */
-export default WebSocket

package/src/websocket/index.js

@@ -1,2 +0,0 @@
-// Uses cjs to optimize out requiring / bundling ws
-export { default } from './websocket.cjs'

package/src/websocket/websocket.cjs

@@ -1,21 +0,0 @@
-/**
- * This is a "light" version of @exodus/core resolution to select the native WebSocket on BE
- * It's a workaround until https://github.com/ExodusMovement/assets/pull/72 is merged.
- *
- * Based on https://github.com/ExodusMovement/fetch/blob/master/core.js , note that chooses native on Desktop
- */
-if (typeof process !== 'undefined' && (process.type === 'renderer' || process.type === 'worker')) {
-  // THIS IS FOR DESKTOP
-  if (process.env.EXODUS_DISABLE_WS) {
-    module.exports = globalThis.WebSocket
-  } else {
-    module.exports = require('ws')
-  }
-  // eslint-disable-next-line no-undef
-} else if (typeof WebSocket === 'undefined') {
-  // THIS IS FOR UNIT TESTING.
-  module.exports = require('ws')
-} else {
-  // THIS IS FOR BE
-  module.exports = globalThis.WebSocket
-}