@exodus/ethereum-api 8.76.5 → 8.76.7

package/src/tx-log/ethereum-no-history-monitor.js

@@ -3,7 +3,7 @@ import { SynchronizedTime } from '@exodus/basic-utils'
 import { Tx } from '@exodus/models'
 import lodash from 'lodash'
 
-import { fromHexToString } from '../number-utils.js'
+import { getBatchedRpcBalances } from './monitor-utils/get-batched-rpc-balances.js'
 import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check.js'
 import {
   excludeUnchangedTokenBalances,
@@ -41,28 +41,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   }
 
   async getBalances({ tokens, ourWalletAddress }) {
-    const batch = Object.create(null)
-    const request = this.server.getBalanceRequest(ourWalletAddress)
-    batch[this.asset.name] = request
-    for (const token of tokens) {
-      const request = this.server.balanceOfRequest(ourWalletAddress, token.contract.address)
-      batch[token.name] = request
-    }
-
-    const pairs = Object.entries(batch)
-    if (pairs.length === 0) {
-      return {}
-    }
-
-    const requests = pairs.map((pair) => pair[1])
-    const responses = await this.server.sendBatchRequest(requests)
-    const entries = pairs.map((pair, idx) => {
-      const balanceHex = responses[idx]
-      const name = pair[0]
-      const balance = fromHexToString(balanceHex)
-      return [name, balance]
-    })
-    return Object.fromEntries(entries)
+    return getBatchedRpcBalances({ baseAsset: this.asset, ourWalletAddress, tokens })
   }
 
   async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {

package/src/tx-log/monitor-utils/get-batched-rpc-balances.js

@@ -0,0 +1,28 @@
+import assert from 'minimalistic-assert'
+
+import { fromHexToString } from '../../number-utils.js'
+
+export const getBatchedRpcBalances = async ({ baseAsset, tokens, ourWalletAddress }) => {
+  assert(baseAsset, 'expected baseAsset')
+  assert(Array.isArray(tokens), 'expected array tokens')
+  assert(ourWalletAddress, 'expected ourWalletAddress')
+
+  const [balance, ...tokenBalances] = await tokens
+    .reduce(
+      (acc, { contract: { address: tokenAddress } }) =>
+        acc.balanceOfRequest(ourWalletAddress, tokenAddress),
+      baseAsset.createRpcRequestAccumulator().getBalanceRequest(ourWalletAddress)
+    )
+    .flush(baseAsset.server)
+
+  return {
+    [baseAsset.name]: fromHexToString(balance),
+    ...Object.fromEntries(
+      tokens.map(({ name, contract: { address: tokenAddress } }, i) => {
+        const tokenBalance = tokenBalances[i]?.confirmed?.[tokenAddress]
+        assert(tokenBalance != null, `missing token balance for ${name} (${tokenAddress})`)
+        return [name, tokenBalance]
+      })
+    ),
+  }
+}

package/src/tx-send/broadcast-error-handler.js

@@ -11,10 +11,15 @@ import { transactionExists } from '../eth-like-util.js'
  * @param {string} options.txId - The transaction ID.
  * @param {boolean} options.isHardware - Whether this is a hardware wallet.
  * @param {string} options.hint - Hint for the error.
+ * @param {boolean} options.isBumpTx - Whether the occur occured whilst bumping a Tx.
+ * @param {boolean} options.isRetryNonceTx - If the error occurred during a nonce bump.
  * @returns {Promise<{ shouldRetry: boolean }>} - Returns if nonce too low and can retry.
  * @throws {EthLikeError} - Throws for all other error cases.
  */
-export const handleBroadcastError = async (err, { asset, txId, isHardware, hint, isBumpTx }) => {
+export const handleBroadcastError = async (
+  err,
+  { asset, txId, isHardware, hint, isBumpTx, isRetryNonceTx }
+) => {
   const message = err.message
 
   const errorInfo = getEvmErrorReason(message) || EVM_ERROR_REASONS.broadcastTxFailed
@@ -46,7 +51,7 @@ export const handleBroadcastError = async (err, { asset, txId, isHardware, hint,
   // NOTE: Don't auto-retry nonce repair for bump/replacement txs.
   // A replacement must keep the *same nonce* as the tx it's replacing.
   // If we "fix" a bump tx by advancing the nonce, we create a brand-new tx instead of replacing the pending one.
-  if (isNonceTooLow && !isHardware && !isBumpTx) return { shouldRetry: true }
+  if (isNonceTooLow && !isHardware && !isBumpTx && !isRetryNonceTx) return { shouldRetry: true }
 
   throw new EthLikeError({
     message: err.message,

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

@@ -100,6 +100,7 @@ const txSendFactory = ({ assetClientInterface, createTx }) => {
             isHardware: false,
             hint: safeString`retry:broadcastTx`,
             isBumpTx: false, // retry path is only for non-bump anyway
+            isRetryNonceTx: true,
           })
         }
       }

package/src/web3/createSimulateMessage.js

@@ -1,6 +1,7 @@
-import { createSimulateMessage as createSimulateEVMMessage } from '@exodus/web3-ethereum-utils'
 import assert from 'minimalistic-assert'
 
+import { createSimulateMessage as createSimulateEVMMessage } from '../simulation/create-simulate-message.js'
+
 export const createSimulateMessage = ({ asset }) => {
   assert(asset, '"asset" should be passed.')
 

package/src/web3/createSimulateTransactions.js

@@ -1,17 +1,11 @@
-import { createSimulateTransactions as createSimulateEVMTransactions } from '@exodus/web3-ethereum-utils'
 import assert from 'minimalistic-assert'
 
+import { simulateTransactions as simulateEthereumTransactions } from '../simulation/simulate-transactions.js'
+
 export const createSimulateTransactions = ({ asset }) => {
   assert(asset, '"asset" should be passed.')
 
-  const simulateEVMTransactions = createSimulateEVMTransactions({
-    apiEndpoint: 'https://simulation.a.exodus.io/simulate',
-    headers: {
-      'X-Api-Version': '2023-06-05',
-    },
-  })
-
   return function simulateTransaction({ transactions, ...restParameters }) {
-    return simulateEVMTransactions({ asset, transactions, ...restParameters })
+    return simulateEthereumTransactions({ asset, transactions, ...restParameters })
   }
 }