@exodus/ethereum-api 8.76.6 → 8.76.7

package/src/simulation/simulate-message-api.js

@@ -0,0 +1,68 @@
+import { makeSimulationAPICall } from '@exodus/web3-utils'
+
+import { BLOWFISH_EVM_CHAINS } from './common.js'
+import { MessageTypeEnum } from './get-message-type.js'
+
+const convertToAPIPayload = ({ address, message, url }) => {
+  const restParameters = {
+    metadata: { origin: url.href },
+    userAccount: address,
+  }
+
+  if (message.messageType === MessageTypeEnum.TypedData) {
+    return {
+      message: {
+        kind: 'SIGN_TYPED_DATA',
+        data: JSON.parse(message.message),
+      },
+      ...restParameters,
+    }
+  }
+
+  return {
+    message: {
+      kind: 'SIGN_MESSAGE',
+      rawMessage: message.message,
+    },
+    ...restParameters,
+  }
+}
+
+export const handleActionResponse = ({ simulationResult, response }) => {
+  if (['BLOCK', 'WARN'].includes(response.action)) {
+    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+    simulationResult.action = response.action
+  }
+}
+
+export const simulateMessageApi = async ({
+  address,
+  apiEndpoint,
+  message,
+  url,
+  headers,
+  simulationResult,
+}) => {
+  const chainInfo = BLOWFISH_EVM_CHAINS[simulationResult.baseAssetName]
+  if (!chainInfo) {
+    return
+  }
+
+  const { network, chain } = chainInfo
+
+  const payload = convertToAPIPayload({ address, message, url })
+
+  const response = await makeSimulationAPICall({
+    url: apiEndpoint,
+    chain,
+    network,
+    payload,
+    headers,
+  })
+
+  if (!response) {
+    return
+  }
+
+  handleActionResponse({ simulationResult, response })
+}

package/src/simulation/simulate-transactions-api.js

@@ -0,0 +1,265 @@
+import { pick } from '@exodus/basic-utils'
+import { createCurrency, makeSimulationAPICall } from '@exodus/web3-utils'
+
+import { BLOWFISH_EVM_CHAINS, MAX_INT256_SOLIDITY } from './common.js'
+
+const convertTransactionToApiPayload = (transactions, origin, blockNumber) => {
+  const payload = {
+    txObjects: transactions.map((transaction) => ({
+      from: transaction.from,
+      to: transaction.to,
+      data: transaction.data,
+      value: transaction.value,
+      gas: transaction.gas,
+      gas_price: transaction.gasPrice,
+    })),
+    metadata: {
+      origin,
+    },
+    userAccount: transactions[0].from,
+  }
+
+  if (blockNumber !== undefined) {
+    payload.blockNumber = blockNumber
+  }
+
+  return payload
+}
+
+const createBalanceAmount = (amount, { decimals, symbol }) => {
+  const beforeAmount = createCurrency({
+    amount: amount.before,
+    symbol,
+    denominator: decimals,
+  })
+  const afterAmount = createCurrency({
+    amount: amount.after,
+    symbol,
+    denominator: decimals,
+  })
+
+  return beforeAmount.sub(afterAmount)
+}
+
+const handleExpectedBalanceChange = (expectedBalanceChange, simulationResult, { network }) => {
+  const { willApprove, willSend, willReceive } = simulationResult.balanceChanges
+  const { data, kind } = expectedBalanceChange.rawInfo
+
+  if (kind === 'FARCASTER_CHANGE_RECOVERY_ADDRESS' || kind === 'ERC20_PERMIT') {
+    return
+  }
+
+  const { asset: simulationAsset } = data
+
+  const isNftTransfer =
+    kind === 'ERC721_TRANSFER' || (kind === 'ERC1155_TRANSFER' && !simulationAsset.decimals)
+  const isNftTransferApproval =
+    kind === 'ERC721_APPROVAL' ||
+    (kind === 'ERC721_APPROVAL_FOR_ALL' && !simulationAsset.decimals) ||
+    (kind === 'ERC1155_APPROVAL_FOR_ALL' && !simulationAsset.decimals)
+  const decimals =
+    isNftTransfer || isNftTransferApproval || !Number.isFinite(simulationAsset.decimals)
+      ? 0
+      : simulationAsset.decimals
+  const simulationAssetInfo = pick(simulationAsset, [
+    'address',
+    'imageUrl',
+    'name',
+    'symbol',
+    'verified',
+  ])
+
+  let symbol = simulationAsset.symbol || simulationAsset.name || 'NFT'
+  if (network === 'polygon' && simulationAsset.symbol === 'MATIC') {
+    symbol = 'POL'
+  }
+
+  if (isNftTransfer || isNftTransferApproval) {
+    simulationAssetInfo.imageUrl = data?.metadata?.rawImageUrl
+  }
+
+  if (
+    kind === 'ERC20_APPROVAL' ||
+    kind === 'ERC721_APPROVAL_FOR_ALL' ||
+    kind === 'ERC1155_APPROVAL_FOR_ALL' ||
+    kind === 'ERC721_APPROVAL'
+  ) {
+    const unitsToUse = symbol || simulationAsset.name || 'Units.'
+
+    const approvingBalance = createCurrency({
+      amount: data.amount.after,
+      symbol: unitsToUse,
+      denominator: decimals,
+    })
+
+    willApprove.push({
+      asset: simulationAssetInfo,
+      spender: data.spender.address,
+      unitName: unitsToUse,
+      balance: approvingBalance,
+      isMaxApproval: approvingBalance._number.gte(MAX_INT256_SOLIDITY),
+    })
+    return
+  }
+
+  const { amount } = data
+
+  const balance = createBalanceAmount(amount, { decimals, symbol })
+
+  if (balance.isZero) {
+    return
+  }
+
+  const balanceChange = {
+    asset: simulationAssetInfo,
+    balance,
+  }
+
+  if (isNftTransfer || isNftTransferApproval) {
+    const tokenId = data.tokenId
+    const compositeId = `${simulationAsset.address}/${tokenId}`
+    balanceChange.nft = {
+      id: `${network}:${compositeId}`,
+      compositeId,
+      title: simulationAsset.name,
+    }
+  }
+
+  if (balance.isNegative) {
+    balanceChange.balance = balanceChange.balance.negate()
+
+    willReceive.push(balanceChange)
+  } else {
+    willSend.push(balanceChange)
+  }
+}
+
+const simulationResultHasAssets = (expectedStateChanges) => {
+  for (const expectedChange of expectedStateChanges) {
+    const { asset: simulationAsset } = expectedChange.rawInfo.data
+    if (!simulationAsset) {
+      return false
+    }
+  }
+
+  return true
+}
+
+export const SimulationErrorMessages = {
+  APICallFailed: 0,
+  SimulationFailed: 1,
+  SimulationNotSupported: 2,
+}
+
+export const simulateTransactionsApi = async ({
+  transactions,
+  apiEndpoint,
+  origin,
+  blockNumber,
+  simulationResult,
+  headers,
+  asset,
+}) => {
+  const successDefaultResult = {
+    kind: 'success',
+    value: undefined,
+  }
+  if (!BLOWFISH_EVM_CHAINS[asset.name]) {
+    return {
+      kind: 'error',
+      error: SimulationErrorMessages.SimulationNotSupported,
+      errorMessage: 'Simulation is not supported for this asset.',
+    }
+  }
+
+  const userAddress = transactions[0].from
+
+  const payload = convertTransactionToApiPayload(transactions, origin, blockNumber)
+
+  if (!Object.hasOwnProperty.call(BLOWFISH_EVM_CHAINS, asset.name)) {
+    return successDefaultResult
+  }
+
+  const { network, chain } = BLOWFISH_EVM_CHAINS[asset.name]
+
+  const response = await makeSimulationAPICall({
+    url: apiEndpoint,
+    chain,
+    network,
+    payload,
+    headers,
+  })
+  if (!response) {
+    return {
+      kind: 'error',
+      error: SimulationErrorMessages.APICallFailed,
+      errorMessage: 'Simulation API call failed.',
+    }
+  }
+
+  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+  simulationResult.metadata.simulatedLocally = false
+
+  const { expectedStateChanges = {}, error } = response.simulationResults.aggregated
+
+  if (error) {
+    return {
+      kind: 'error',
+      error: SimulationErrorMessages.SimulationFailed,
+      errorMessage: error?.humanReadableError,
+    }
+  }
+
+  const { action } = response
+
+  if (action === 'BLOCK') {
+    simulationResult.warnings.push({
+      kind: 'MALICIOUS_ACTION',
+      severity: 'CRITICAL',
+      message: 'This dApp could be malicious. Do not proceed unless you are certain this is safe.',
+    })
+  } else if (action === 'WARN') {
+    simulationResult.warnings.push({
+      kind: 'SUSPICIOUS_ACTION',
+      severity: 'MEDIUM',
+      message: 'This transaction may be suspicious. Proceed with caution.',
+    })
+  }
+
+  const noExpectedStateChangesDetected = Object.keys(expectedStateChanges).length === 0
+
+  if (noExpectedStateChangesDetected) {
+    simulationResult.balanceChanges.willSend.push({
+      balance: createCurrency({
+        amount: 0,
+        symbol: asset.displayTicker,
+        denominator: asset.currency.defaultUnit.power,
+      }),
+    })
+
+    return successDefaultResult
+  }
+
+  const userExpectedChanges = Object.keys(expectedStateChanges).reduce((prev, address) => {
+    if (userAddress.toLowerCase() !== address.toLowerCase()) {
+      return prev
+    }
+
+    const result =
+      (Object.prototype.hasOwnProperty.call(expectedStateChanges, address) &&
+        expectedStateChanges[address]) ||
+      []
+
+    return [...prev, ...result]
+  }, [])
+
+  if (!simulationResultHasAssets(userExpectedChanges)) {
+    return successDefaultResult
+  }
+
+  userExpectedChanges.forEach((expectedChange) => {
+    handleExpectedBalanceChange(expectedChange, simulationResult, { network })
+  })
+
+  return successDefaultResult
+}

package/src/simulation/simulate-transactions.js

@@ -0,0 +1,16 @@
+import assert from 'minimalistic-assert'
+
+import { createSimulateTransactions } from './create-simulate-transactions.js'
+
+const simulateEVMTransactions = createSimulateTransactions({
+  apiEndpoint: 'https://simulation.a.exodus.io/simulate',
+  headers: {
+    'X-Api-Version': '2023-06-05',
+  },
+})
+
+export function simulateTransactions({ asset, transactions, ...restParameters }) {
+  assert(asset, '"asset" should be passed.')
+
+  return simulateEVMTransactions({ asset, transactions, ...restParameters })
+}

package/src/simulation/transactions.js

@@ -0,0 +1,52 @@
+import SolidityContract from '@exodus/solidity-contract'
+
+export function getDisplayDetails(willApprove) {
+  let title = 'Approve Transaction?'
+  const isApproveTransaction = willApprove.length
+
+  if (isApproveTransaction) {
+    const tokenName = willApprove[0].unitName
+    title = tokenName ? `Approve ${tokenName} Transactions?` : title
+  }
+
+  return { title }
+}
+
+export const isSimpleTransfer = (transaction) => {
+  return ['0x', null, undefined].includes(transaction.data)
+}
+
+export const getTxFeeDetails = (transaction) => {
+  const maxFeePerGas = transaction.maxFeePerGas
+  const gasPrice = transaction.gasPrice
+  const gasLimit = transaction.gas
+
+  return {
+    gasLimit,
+    maxFeePerGas,
+    gasPrice,
+  }
+}
+
+export function decodeRecipientAddresses(transaction) {
+  try {
+    if (!transaction.to) {
+      return []
+    }
+
+    if (isSimpleTransfer(transaction)) {
+      return [transaction.to]
+    }
+
+    const token = SolidityContract.erc20(transaction.to)
+    const { method, values } = token.decodeInput(transaction.data)
+
+    if (method === 'transfer') {
+      return [values[0]]
+    }
+
+    return []
+  } catch {
+    return []
+  }
+}

package/src/simulation/try-estimating-changes-locally.js

@@ -0,0 +1,26 @@
+import { estimateSimpleTransfer, NotSimpleTransferError } from './estimate-simple-transfer.js'
+
+export const tryEstimatingChangesLocally = ({ asset, simulationResult, transaction }) => {
+  if (typeof transaction.from !== 'string' || typeof transaction.to !== 'string') {
+    return false
+  }
+
+  try {
+    const estimatedValue = estimateSimpleTransfer({ baseAsset: asset, transaction })
+    const actualTransferValue =
+      transaction.from.toLowerCase() === transaction.to.toLowerCase()
+        ? asset.currency.ZERO
+        : estimatedValue
+    simulationResult.balanceChanges.willSend.push({
+      balance: actualTransferValue,
+    })
+
+    return true
+  } catch (err) {
+    if (!(err instanceof NotSimpleTransferError)) {
+      // TODO: accept a logger dep and log the unexpected local simulation error.
+    }
+
+    return false
+  }
+}

package/src/staking/ethereum/staking-utils.js

@@ -3,6 +3,7 @@ import { parseUnsignedTx } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
 import assert from 'minimalistic-assert'
 
+import { simulateTransactions as simulateEthereumTransactions } from '../../simulation/simulate-transactions.js'
 import { EthereumStaking, UNSTAKE_DEFAULTS } from './api.js'
 import { simulateEverstakeUnstake } from './everstake.js'
 
@@ -211,7 +212,8 @@ export async function simulateUndelegateTransactions({
 
   if (transactions.length === 0) return
 
-  const simulationResponse = await asset.baseAsset.api.web3.simulateTransactions({
+  const simulationResponse = await simulateEthereumTransactions({
+    asset: asset.baseAsset,
     baseAssetName: asset.baseAsset.name,
     origin: 'exodus-staking',
     senderAddress,

package/src/staking/matic/matic-staking-utils.js

@@ -4,6 +4,7 @@ import assetsList, { asset as ethereum } from '@exodus/ethereum-meta'
 import { Tx } from '@exodus/models'
 import assert from 'minimalistic-assert'
 
+import { simulateTransactions as simulateEthereumTransactions } from '../../simulation/simulate-transactions.js'
 import { decodePolygonStakingTxInputAmount } from '../../tx-log-staking-processor/utils.js'
 import { MaticStakingApi } from './api.js'
 
@@ -211,7 +212,8 @@ export async function maticDelegateSimulateTransactions({
     senderAddress,
   }
 
-  const simulationResponse = await asset.baseAsset.api.web3.simulateTransactions({
+  const simulationResponse = await simulateEthereumTransactions({
+    asset: asset.baseAsset,
     ...simulationTxData,
     transactions: [approveTxRequest, delegateTxRequest],
   })

package/src/tx-log/clarity-truncated-history-monitor.js

@@ -75,6 +75,40 @@ export class ClarityTruncatedHistoryMonitor extends ClarityMonitor {
     let clarityCursor
 
     try {
+      // When refreshing, we need to clear out old asset
+      // balances in `accountState` since these can surface
+      // values populated from alternative monitors i.e.
+      // `no-history`, which can be written at arbitrary
+      // points in time.
+      //
+      // Since the `truncated-history-monitor` does not
+      // guarantee an `accountState` write for an asset,
+      // (these are only provided when the history is
+      // truncated), we must ensure older checkpoints cannot
+      // be inadvertently relied upon.
+      //
+      if (refresh) {
+        const defaultAccountState = this.asset.api.createAccountState().create()
+
+        const currentAccountState = derivedData.currentAccountState ?? defaultAccountState
+
+        const resetTokenBalances = {
+          balance: defaultAccountState.balance,
+          tokenBalances: defaultAccountState.tokenBalances,
+        }
+
+        // Optimistically update the `derivedData` for downstream.
+        derivedData.currentAccountState = currentAccountState.merge(resetTokenBalances)
+
+        this.aci.updateAccountStateBatch({
+          assetName,
+          walletAccount,
+          accountState: currentAccountState,
+          newData: resetTokenBalances,
+          batch,
+        })
+      }
+
       const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
 
       ;({ allTxs } = await normalizeTransactionsResponse({

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 })
   }
 }