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

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

@@ -0,0 +1,266 @@
+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, recipientAddress) => {
+  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: recipientAddress ? { origin, recipientAddress } : { 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, balanceChanges, { network }) => {
+  const { willApprove, willSend, willReceive } = balanceChanges
+  const { data, kind } = expectedBalanceChange.rawInfo
+
+  if (kind === 'FARCASTER_CHANGE_RECOVERY_ADDRESS' || kind === 'ERC20_PERMIT') {
+    return
+  }
+
+  const { asset: simulationAsset } = data
+
+  if (!simulationAsset) {
+    return
+  }
+
+  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)
+  }
+}
+
+export const SimulationErrorMessages = {
+  APICallFailed: 0,
+  SimulationFailed: 1,
+  SimulationNotSupported: 2,
+}
+
+export const simulateTransactionsApi = async ({
+  transactions,
+  apiEndpoint,
+  origin,
+  blockNumber,
+  recipientAddress,
+  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,
+    recipientAddress
+  )
+
+  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/hydra/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 userAddressLower = userAddress.toLowerCase()
+  const recipientAddressLower =
+    recipientAddress && recipientAddress.toLowerCase() !== userAddressLower
+      ? recipientAddress.toLowerCase()
+      : undefined
+
+  const relevantExpectedChanges = Object.entries(expectedStateChanges).flatMap(
+    ([address, changes]) => {
+      const addressLower = address.toLowerCase()
+      const isUserOwned = addressLower === userAddressLower
+      if (!isUserOwned && addressLower !== recipientAddressLower) {
+        return []
+      }
+
+      return (changes ?? []).map((change) => ({ change, isUserOwned }))
+    }
+  )
+
+  const noExpectedStateChangesDetected = relevantExpectedChanges.length === 0
+
+  if (noExpectedStateChangesDetected) {
+    simulationResult.balanceChanges.willSend.push({
+      balance: createCurrency({
+        amount: 0,
+        symbol: asset.displayTicker,
+        denominator: asset.currency.defaultUnit.power,
+      }),
+    })
+
+    return successDefaultResult
+  }
+
+  relevantExpectedChanges.forEach(({ change, isUserOwned }) => {
+    const balanceChanges = isUserOwned
+      ? simulationResult.balanceChanges
+      : simulationResult.recipientBalanceChanges
+    handleExpectedBalanceChange(change, balanceChanges, { 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/api/index.js

@@ -0,0 +1,43 @@
+import assert from 'minimalistic-assert'
+
+export const stakingApiFactory = ({
+  assetName,
+  currency,
+  assetClientInterface,
+  server, // coin node server
+  stakingConfiguration,
+  stakingDependencies,
+  createRpcRequestAccumulator,
+}) => {
+  assert(assetName, '"assetName" is required')
+  assert(currency, '"currency" is required')
+  assert(assetClientInterface, '"assetClientInterface" is required')
+  assert(server, '"server" is required')
+  assert(stakingConfiguration, '"stakingConfiguration" is required')
+  assert(stakingDependencies, '"stakingDependencies" is required')
+
+  const { contracts, minAmount } = stakingConfiguration
+  const { stakingServerFactory, stakingServiceFactory } = stakingDependencies
+
+  const stakingServer = stakingServerFactory({
+    assetName,
+    currency,
+    server,
+    minAmount,
+    contracts,
+    createRpcRequestAccumulator,
+  })
+
+  const stakingService = stakingServiceFactory({
+    assetClientInterface,
+    server,
+    stakingServer,
+  })
+
+  return {
+    ...stakingService,
+    isStaking: async ({ isDelegating }) => isDelegating,
+    isUnstaking: async ({ isUndelegateInProgress }) => isUndelegateInProgress,
+    isUnstaked: async ({ canClaimUndelegateBalance }) => canClaimUndelegateBalance,
+  }
+}

package/src/staking/cached-read.js

@@ -0,0 +1,33 @@
+// Background-only caching. Callers outside the monitor always request fresh data.
+// Keep this state in memory: restored accounts must be discovered again immediately.
+export const createCachedStakingRead = ({
+  read,
+  interval = 15 * 60_000,
+  now = () => performance.now(),
+}) => {
+  const entries = new Map()
+  return async (key, { useCache = false } = {}) => {
+    let entry = entries.get(key)
+    if (!entry) {
+      entry = { generation: 0 }
+      entries.set(key, entry)
+    }
+    if (useCache) {
+      if (entry.pending) return entry.pending
+      if (entry.deadline > now()) return entry.value
+    }
+    const generation = ++entry.generation
+    const pending = Promise.resolve().then(() => read(key))
+    entry.pending = pending
+    try {
+      const value = await pending
+      if (entry.generation === generation) {
+        entry.value = value
+        entry.deadline = now() + interval
+      }
+      return value
+    } finally {
+      if (entry.generation === generation) entry.pending = undefined
+    }
+  }
+}