@exodus/ethereum-api 8.76.5 → 8.76.7

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

@@ -0,0 +1,106 @@
+import { createEmptySimulationResult } from '@exodus/web3-utils'
+
+import { estimateFee } from './estimate-fee.js'
+import { simulateTransactionsApi } from './simulate-transactions-api.js'
+import { decodeRecipientAddresses, getDisplayDetails, getTxFeeDetails } from './transactions.js'
+import { tryEstimatingChangesLocally } from './try-estimating-changes-locally.js'
+
+export const createSimulateTransactions =
+  ({ apiEndpoint, headers: headersFromDeps }) =>
+  async ({
+    transactions,
+    asset,
+    origin,
+    blockNumber,
+    headers: headersFromParams,
+    overrideApiEndpoint,
+  }) => {
+    const headers = { ...headersFromDeps, ...headersFromParams }
+
+    const simulationResult = createEmptySimulationResult({
+      asset,
+    })
+
+    if (transactions.length === 0) {
+      const message = 'No transactions provided. Cannot simulate transaction batch.'
+      simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+      simulationResult.metadata.humanReadableError = message
+      return simulationResult
+    }
+
+    const firstFrom = transactions[0].from.toLowerCase()
+    const hasMismatchedFrom = transactions.some((tx) => tx.from.toLowerCase() !== firstFrom)
+    if (hasMismatchedFrom) {
+      const message =
+        'All transactions in a batch must have the same "from" address. Cannot simulate transaction batch.'
+      simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+      simulationResult.metadata.humanReadableError = message
+      return simulationResult
+    }
+
+    const hasInvalidTransaction = transactions.some((tx) => !tx.to)
+    if (hasInvalidTransaction) {
+      const message =
+        'One or more transactions are missing required "to" address. Cannot simulate transaction batch.'
+      simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+      simulationResult.metadata.humanReadableError = message
+      return simulationResult
+    }
+
+    simulationResult.recipientAddresses = transactions.map((tx) => decodeRecipientAddresses(tx))
+    const feeCurrency = asset.feeAsset.currency
+
+    const simulationTransactionInternalResult = await simulateTransactionsApi({
+      asset,
+      transactions,
+      apiEndpoint: overrideApiEndpoint || apiEndpoint,
+      origin,
+      blockNumber,
+      simulationResult,
+      headers,
+    })
+
+    if (simulationTransactionInternalResult.kind === 'error') {
+      if (transactions.length > 1) {
+        const message = 'Cannot locally simulate batched transactions.'
+        simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+        simulationResult.metadata.humanReadableError = message
+      } else {
+        const transaction = transactions[0]
+        const simulatedLocally = tryEstimatingChangesLocally({
+          asset,
+          simulationResult,
+          transaction,
+        })
+        if (simulatedLocally) {
+          simulationResult.metadata.simulatedLocally = true
+          simulationResult.balanceChanges.willPayFee.push({
+            balance: estimateFee({ feeCurrency, transaction }),
+            feeDetails: getTxFeeDetails(transaction),
+          })
+        } else {
+          const message = 'Balance changes cannot be estimated.'
+          simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+          simulationResult.metadata.humanReadableError = message
+        }
+      }
+
+      if (simulationTransactionInternalResult.errorMessage) {
+        simulationResult.metadata.humanReadableError =
+          simulationTransactionInternalResult.errorMessage
+      }
+
+      return simulationResult
+    }
+
+    for (const transaction of transactions) {
+      simulationResult.balanceChanges.willPayFee.push({
+        balance: estimateFee({ feeCurrency, transaction }),
+        feeDetails: getTxFeeDetails(transaction),
+      })
+    }
+
+    simulationResult.displayDetails = getDisplayDetails(simulationResult.balanceChanges.willApprove)
+
+    return simulationResult
+  }

package/src/simulation/estimate-fee.js

@@ -0,0 +1,14 @@
+import { hexToBN } from '@exodus/web3-utils'
+
+export const estimateFee = ({ feeCurrency, transaction }) => {
+  const gas = hexToBN(transaction.gas)
+
+  if (transaction.maxFeePerGas) {
+    const maxFeePerGas = hexToBN(transaction.maxFeePerGas)
+    const maximumFee = gas.mul(maxFeePerGas)
+    return feeCurrency.baseUnit(maximumFee.toString())
+  }
+
+  const gasPrice = hexToBN(transaction.gasPrice)
+  return feeCurrency.baseUnit(gas.mul(gasPrice).toString())
+}

package/src/simulation/estimate-simple-transfer.js

@@ -0,0 +1,15 @@
+import { hexToBN } from '@exodus/web3-utils'
+
+import { isSimpleTransfer } from './transactions.js'
+
+export class NotSimpleTransferError extends Error {}
+
+export const estimateSimpleTransfer = ({ baseAsset, transaction }) => {
+  if (!isSimpleTransfer(transaction)) {
+    throw new NotSimpleTransferError('The transaction input should be empty ("0x").')
+  }
+
+  const txValue = hexToBN(transaction.value || '0x0').toString()
+
+  return baseAsset.currency.baseUnit(txValue)
+}

package/src/simulation/get-message-type.js

@@ -0,0 +1,18 @@
+export const MessageTypeEnum = {
+  RawMessage: 0,
+  TypedData: 1,
+  Unknown: 2,
+}
+
+export const getMessageType = (message) => {
+  if (typeof message !== 'string') {
+    return MessageTypeEnum.Unknown
+  }
+
+  try {
+    JSON.parse(message)
+    return MessageTypeEnum.TypedData
+  } catch {
+    return MessageTypeEnum.RawMessage
+  }
+}

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({