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

package/src/nft-utils.js

@@ -0,0 +1,60 @@
+import { safeString } from '@exodus/safe-string'
+import SolidityContract from '@exodus/solidity-contract'
+import assert from 'minimalistic-assert'
+
+import { EthLikeError, EVM_ERROR_REASONS } from './error-wrapper.js'
+import { fetchGasLimit } from './gas-estimation.js'
+
+export const getNftArguments = async ({ asset, nft, fromAddress, toAddress }) => {
+  assert(asset, 'asset is required')
+  assert(nft, 'nft is required')
+  assert(fromAddress, 'fromAddress is required')
+  assert(toAddress, 'toAddress is required')
+  const { contractAddress, tokenId, contractType } = nft
+
+  const txInputs = []
+
+  if (!contractType || contractType === 'erc1155') {
+    const txInput = `0x${SolidityContract.simpleErc1155(contractAddress)
+      .safeTransferFrom.build(fromAddress, toAddress, tokenId, 1, [])
+      .toString('hex')}`
+    txInputs.push({ txInput, contractType: 'erc1155' })
+  }
+
+  if (!contractType || contractType === 'erc721') {
+    const txInput = `0x${SolidityContract.simpleErc721(contractAddress)
+      .safeTransferFrom.build(fromAddress, toAddress, tokenId)
+      .toString('hex')}`
+    txInputs.push({ txInput, contractType: 'erc721' })
+  }
+
+  const errors = [`Cannot fetch gas for ${asset.name}`]
+  const { txInput, gasLimit } = await Promise.any(
+    txInputs.map(async ({ txInput, contractType }) => {
+      try {
+        const gasLimit = await fetchGasLimit({
+          asset,
+          fromAddress,
+          contractAddress,
+          txInput,
+        })
+        return { txInput, gasLimit }
+      } catch (e) {
+        errors.push(`ContractType ${contractType} nft input ${txInput}. ${e.message}`)
+        throw e
+      }
+    })
+  ).catch((e) => {
+    throw new EthLikeError({
+      message: errors.join('\n'),
+      errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+      hint: safeString`getNftArguments`,
+      traceId: e.traceId,
+    })
+  })
+  return {
+    contractAddress,
+    gasLimit,
+    txInput,
+  }
+}

package/src/number-utils.js

@@ -1,8 +1,40 @@
+import BN from 'bn.js'
+
 export function fromHexToString(value) {
   return fromHexToBigInt(value).toString()
 }
 
 export function fromHexToBigInt(value) {
-  const hex = value.startsWith('0x') ? value : '0x' + value
-  return BigInt(hex)
+  return BigInt(addHexPrefix(value))
+}
+
+export const addHexPrefix = (str) => {
+  if (typeof str !== 'string') {
+    return str
+  }
+
+  return str.startsWith('0x') ? str : '0x' + str
+}
+
+export const removeHexPrefix = (str) => {
+  if (typeof str !== 'string' || str === '') {
+    return str
+  }
+
+  return str.startsWith('0x') ? str.slice(2) : str
+}
+
+export const splitIn32BytesArray = (output) => {
+  const trimmed = removeHexPrefix(output)
+  const result = trimmed.match(/^([\da-f]{64})+$/gi)
+  if (result) {
+    return trimmed.match(/.{64}/g)
+  }
+
+  throw new Error(`${output} is not a 64 bytes hex that can be split`)
 }
+
+export const removeLeadingZeroes = (str) => str.replace(/^0+/, '')
+
+// Deprecated, use BigInt
+export const fromHexToBN = (str) => new BN(removeLeadingZeroes(removeHexPrefix(str)), 16)

package/src/optimism-gas/index.js

@@ -1,8 +1,11 @@
-import * as ethUtil from '@exodus/ethereumjs-util'
-import { createEthereumJsTx, createContract } from '@exodus/ethereum-lib'
-import { fromHexToBigInt } from '../number-utils'
+import { createContract, createEthereumJsTx } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import assert from 'minimalistic-assert'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../error-wrapper.js'
+import { fromHexToBigInt } from '../number-utils.js'
+
 export const estimateL1DataFeeFactory = ({ l1GasOracleAddress, server }) => {
   assert(l1GasOracleAddress, 'l1GasOracleAddress is required')
   assert(server, 'server is required')
@@ -12,8 +15,13 @@ export const estimateL1DataFeeFactory = ({ l1GasOracleAddress, server }) => {
     const serialized = ethjsTx.serialize()
     const callData = gasContract.getL1Fee.build(serialized)
     const buffer = Buffer.from(callData)
-    const data = ethUtil.bufferToHex(buffer)
-    const hex = await server.ethCall({ to: l1GasOracleAddress, data }, 'latest')
+    const data = bufferToHex(buffer)
+    const hex = await withErrorReason({
+      promise: server.ethCall({ to: l1GasOracleAddress, data }, 'latest'),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`estimateL1DataFee`,
+      baseAssetName: server.baseAssetName,
+    })
     const l1DataFee = fromHexToBigInt(hex)
     const padFee = l1DataFee / BigInt(4)
     const maxL1DataFee = l1DataFee + padFee

package/src/send-validations.js

@@ -0,0 +1,58 @@
+import sendValidationModel from '@exodus/send-validation-model'
+import assert from 'minimalistic-assert'
+
+const { FIELDS, PRIORITY_LEVELS, VALIDATION_TYPES } = sendValidationModel
+
+export const SCAM_RECIPIENT = 'SCAM_RECIPIENT'
+export const SCAM_RECIPIENT_MESSAGE =
+  'This recipient was flagged as risky. Please verify before sending.'
+
+const toWalletAccountId = (fromWalletAccount) =>
+  typeof fromWalletAccount === 'string' ? fromWalletAccount : fromWalletAccount?.toString?.()
+
+export const createSendValidations = ({ assetClientInterface, checkTx }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(typeof checkTx === 'function', 'checkTx must be a function')
+
+  const scamRecipientValidator = {
+    id: SCAM_RECIPIENT,
+    type: VALIDATION_TYPES.WARN,
+    field: FIELDS.ADDRESS,
+    priority: PRIORITY_LEVELS.MIDDLE,
+    validateAndGetMessage: async ({ asset, destinationAddress, sendAmount, fromWalletAccount }) => {
+      // M1: native sends only. M2 will cover tokens/approvals/contract calls
+      // via a post-createTx call site on the review screen.
+      if (!asset || asset.name !== asset.baseAsset.name) return
+      if (!destinationAddress || !sendAmount) return
+      if (sendAmount.isZero) return
+
+      const isValidAddress = await asset.address.validate(destinationAddress)
+      if (!isValidAddress) return
+
+      const walletAccountId = toWalletAccountId(fromWalletAccount)
+      if (!walletAccountId) return
+
+      const fromAddress = await assetClientInterface.getReceiveAddress({
+        assetName: asset.name,
+        walletAccount: walletAccountId,
+        useCache: true,
+      })
+      if (!fromAddress) return
+
+      // Native send: empty calldata, no signed tx hash to pass yet.
+      const result = await checkTx({
+        chain: asset.chainId,
+        fromAddress,
+        toAddress: destinationAddress,
+        value: sendAmount.toBaseString({ unit: false }),
+        input: '0x',
+      })
+
+      if (result?.action !== 'WARN') return
+
+      return result.reason || SCAM_RECIPIENT_MESSAGE
+    },
+  }
+
+  return [scamRecipientValidator]
+}

package/src/server-based-fee-monitor.js

@@ -1,7 +1,7 @@
 import { FeeMonitor } from '@exodus/asset-lib'
 import assert from 'minimalistic-assert'
-import { DEFAULT_FEE_MONITOR_INTERVAL } from '@exodus/ethereum-lib'
-import { fromHexToString } from './number-utils'
+
+import { calculateEthLikeFeeMonitorUpdate } from './fee-utils.js'
 
 /**
  * Generic eth server based fee monitor.
@@ -12,39 +12,32 @@ import { fromHexToString } from './number-utils'
  *
  * const api = {
  *  ...
- *  createFeeMonitor: serverBasedFeeMonitorFactoryFactory({ interval: '50s', server, assetName: base.name }),
+ *  createFeeMonitor: serverBasedFeeMonitorFactoryFactory({ interval: '50s', server, asset, aci }),
  *  ...
  * }
  */
 
-export const serverBasedFeeMonitorFactoryFactory = ({
-  assetName,
-  interval = DEFAULT_FEE_MONITOR_INTERVAL,
-  eip1559Enabled,
-  server,
-}) => {
-  assert(assetName, 'assetName is required')
+export const serverBasedFeeMonitorFactoryFactory = ({ asset, interval, server, aci }) => {
+  assert(asset, 'asset is required')
   assert(server, 'server is required')
+  assert(aci, 'aci is required')
 
   const FeeMonitorClass = class ServerBaseEthereumFeeMonitor extends FeeMonitor {
     constructor({ updateFee }) {
       assert(updateFee, 'updateFee is required')
       super({
         updateFee,
-        assetName,
+        assetName: asset.name,
         interval,
       })
     }
 
     async fetchFee() {
-      const gasPrice = fromHexToString(await server.getGasPrice())
-
-      const baseFeePerGas = eip1559Enabled ? `${await server.getBaseFeePerGas()} wei` : undefined
-
-      return {
-        gasPrice: `${gasPrice} wei`,
-        baseFeePerGas,
-      }
+      return calculateEthLikeFeeMonitorUpdate({
+        assetClientInterface: aci,
+        feeAsset: asset,
+        fetchedGasPrices: await server.getGasPriceEstimation(),
+      })
     }
   }
   return (...args) => new FeeMonitorClass(...args)

package/src/simulate-tx/fetch-tx-preview.js

@@ -1,5 +1,3 @@
-import { fetch } from '@exodus/fetch'
-
 const ETHEREUM_TX_PREVIEW_API = 'https://simulation.a.exodus.io/simulate'
 
 export async function fetchTxPreview(transaction) {

package/src/simulate-tx/index.js

@@ -1,2 +1,2 @@
-export * from './fetch-tx-preview'
-export * from './simulate-eth-tx'
+export * from './fetch-tx-preview.js'
+export * from './simulate-eth-tx.js'

package/src/simulate-tx/simulate-eth-tx.js

@@ -1,18 +1,29 @@
-import assert from 'minimalistic-assert'
-import { asset as ethereum } from '@exodus/ethereum-meta'
 import {
+  APPROVE_METHOD_ID,
   checkIsERC721InputData,
   checkIsNFTInputData,
-  APPROVE_METHOD_ID,
 } from '@exodus/ethereum-lib'
+import { asset as ethereum } from '@exodus/ethereum-meta'
 import SolidityContract from '@exodus/solidity-contract'
+import assert from 'minimalistic-assert'
 
-import { fetchTxPreview } from './fetch-tx-preview'
-import { getERC20Params } from '../eth-like-util'
+import { getERC20Params } from '../eth-like-util.js'
+import { fromHexToBigInt } from '../number-utils.js'
+import { fetchTxPreview } from './fetch-tx-preview.js'
 
 const ethDecimals = ethereum.units.ETH
 
-const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
+// Convert a hex transaction field (e.g. "0x10a741a462780000" for 1.2 ETH in wei)
+// to a precision-preserving decimal string. `parseInt` would silently truncate
+// values above Number.MAX_SAFE_INTEGER (~9e15), and Ethereum wei amounts routinely
+// exceed that (1 ETH = 1e18 wei).
+const ethHexToDecimalString = (hexValue) => {
+  if (hexValue === undefined || hexValue === null || hexValue === '' || hexValue === '0x') {
+    return '0'
+  }
+
+  return fromHexToBigInt(hexValue).toString()
+}
 
 async function getAssetSymbolFromContract(contractAddress, asset) {
   const { symbol: assetSymbol } = await getERC20Params({
@@ -169,14 +180,16 @@ export async function retrieveSideEffects({ transaction, asset, shouldSimulate =
 
   if (!transaction.to) throw new Error(`'to' field is missing in the TX object`)
 
+  const txValueDecimal = ethHexToDecimalString(transaction.value)
+
   const blocknativeTxObject = {
     to: transaction.to,
     input: transaction.data,
     from: transaction.from,
-    value: ethHexToInt(transaction.value),
-    gas: ethHexToInt(transaction.gas),
-    maxFeePerGas: ethHexToInt(transaction.maxFeePerGas),
-    maxPriorityFeePerGas: ethHexToInt(transaction.maxPriorityFeePerGas),
+    value: txValueDecimal,
+    gas: ethHexToDecimalString(transaction.gas),
+    maxFeePerGas: ethHexToDecimalString(transaction.maxFeePerGas),
+    maxPriorityFeePerGas: ethHexToDecimalString(transaction.maxPriorityFeePerGas),
   }
 
   try {
@@ -224,7 +237,7 @@ export async function retrieveSideEffects({ transaction, asset, shouldSimulate =
     if (willSend.length === 0) {
       willSend.push({
         symbol: 'ETH',
-        balance: `-${ethHexToInt(transaction.value)}`,
+        balance: `-${txValueDecimal}`,
         assetType: 'ether',
         decimal: ethDecimals,
       })

package/src/simulation/common.js

@@ -0,0 +1,34 @@
+import BN from 'bn.js'
+
+export const BLOWFISH_EVM_CHAINS = {
+  avalanchec: {
+    network: 'avalanche',
+    chain: 'mainnet',
+  },
+  basemainnet: {
+    network: 'base',
+    chain: 'mainnet',
+  },
+  bsc: {
+    network: 'bnb',
+    chain: 'mainnet',
+  },
+  ethereum: {
+    network: 'ethereum',
+    chain: 'mainnet',
+  },
+  ethereumarbone: {
+    network: 'arbitrum',
+    chain: 'one',
+  },
+  matic: {
+    network: 'polygon',
+    chain: 'mainnet',
+  },
+  optimism: {
+    network: 'optimism',
+    chain: 'mainnet',
+  },
+}
+
+export const MAX_INT256_SOLIDITY = new BN(2).pow(new BN(255)).subn(1)

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

@@ -0,0 +1,49 @@
+import { tryParsingSIWE } from '@exodus/web3-utils'
+import assert from 'minimalistic-assert'
+
+import { getMessageType, MessageTypeEnum } from './get-message-type.js'
+import { simulateMessageApi } from './simulate-message-api.js'
+
+export const createSimulateMessage =
+  ({
+    apiEndpoint = 'https://simulation.a.exodus.io/simulateMessage',
+    headers = {
+      'X-Api-Version': '2023-06-05',
+    },
+  } = {}) =>
+  async ({ message, url, asset, address }) => {
+    assert(url instanceof URL, "'url' should be an instance of the URL object.")
+
+    const simulationResult = {
+      baseAssetName: asset.baseAssetName,
+      action: 'NONE',
+    }
+
+    const messageType = getMessageType(message)
+    if (messageType === MessageTypeEnum.Unknown) {
+      return simulationResult
+    }
+
+    if (messageType === MessageTypeEnum.RawMessage) {
+      tryParsingSIWE({
+        address,
+        message,
+        url,
+        simulationResult,
+      })
+    }
+
+    await simulateMessageApi({
+      address,
+      message: {
+        message,
+        messageType,
+      },
+      url,
+      apiEndpoint,
+      headers,
+      simulationResult,
+    })
+
+    return simulationResult
+  }

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

@@ -0,0 +1,108 @@
+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,
+    recipientAddress,
+    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,
+      recipientAddress,
+      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/hydra/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 })
+}