@exodus/ethereum-api 2.15.1 → 2.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.15.1",
+  "version": "2.16.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -12,9 +12,10 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.5.4",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.14.1",
+    "@exodus/ethereum-lib": "^2.15.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/simple-retry": "^0.0.6",
+    "@exodus/solidity-contract": "^1.0.1",
     "fetchival": "0.3.3",
     "make-concurrent": "4.0.0",
     "minimalistic-assert": "^1.0.1",
@@ -28,5 +29,5 @@
     "@exodus/assets-base": "^8.0.136",
     "@exodus/models": "^8.7.2"
   },
-  "gitHead": "eb59c41504a3c004bafbab789bf5f50a9f40d020"
+  "gitHead": "e82aa2dcf0a729e17ec2c7e304625fc6ae9d66a4"
 }

package/src/eth-like-util.js

@@ -1,6 +1,8 @@
-import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken } from '@exodus/ethereum-lib'
+import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken, ABI } from '@exodus/ethereum-lib'
 import { eth, serverMap, getServer } from './exodus-eth-server'
 import { memoizeLruCache } from '@exodus/asset-lib'
+import assets from '@exodus/assets'
+import SolidityContract from '@exodus/solidity-contract'
 
 // Mobile only.
 // Behavior is buggy, because the default server used is ethereum.
@@ -74,3 +76,72 @@ export const getIsForwarderContract = memoizeLruCache(
   ({ asset, address }) => `${asset.name}:${address}`,
   { max: 100 }
 )
+
+const ERC20 = new SolidityContract(ABI.erc20)
+const ERC20BytesParams = new SolidityContract(ABI.erc20BytesParams)
+const DEFAULT_PARAM_NAMES = ['decimals', 'name', 'symbol']
+const erc20ParamsCache = {}
+
+export const getERC20Params = async ({
+  assetName,
+  address,
+  paramNames = DEFAULT_PARAM_NAMES,
+} = {}) => {
+  const asset = assets[assetName]
+  if (!asset) {
+    throw new Error(`${assetName} not found`)
+  }
+  if (!address) {
+    throw new Error(`Token address should be provided, got: ${address}`)
+  }
+
+  const cacheKey = `${address}:${paramNames}`
+  if (erc20ParamsCache[cacheKey]) {
+    return erc20ParamsCache[cacheKey]
+  }
+
+  const server = getServer(asset)
+
+  const paramValues = await Promise.all(
+    paramNames.map(async (method) => {
+      let callResponse
+      try {
+        callResponse = await server.ethCall({ to: address, data: ERC20[method].methodId })
+      } catch (err) {
+        if (err.message === 'execution reverted') {
+          throw Error(
+            `Can't find parameters for contract with address ${address}. Are you sure it is a valid ERC20 contract?`
+          )
+        }
+
+        throw Error(err.message)
+      }
+
+      if (method === 'decimals') return parseInt(callResponse)
+
+      try {
+        return ERC20.decodeOutput({ method, data: callResponse })[0]
+      } catch (err) {
+        // sometimes ERC20s violate the standard and use 'bytes32' type instead of 'string'
+        if (err.message.includes('overflow') && callResponse) {
+          const hex = ERC20BytesParams.decodeOutput({ method, data: callResponse })[0]
+          const rawName = Buffer.from(hex.split('0x')[1], 'hex').toString()
+
+          // trims 'Maker\x00\x00\x00...' to 'Maker'
+          return rawName.slice(0, rawName.indexOf('\x00'))
+        }
+      }
+    })
+  )
+
+  const response = paramNames.reduce(
+    (accumulatedObj, paramName, index) => ({
+      ...accumulatedObj,
+      [paramName]: paramValues[index],
+    }),
+    {}
+  )
+  erc20ParamsCache[cacheKey] = response
+
+  return response
+}

package/src/exodus-eth-server/api.js

@@ -4,7 +4,7 @@ import fetchival from 'fetchival'
 import ms from 'ms'
 import createWebSocket from './ws'
 import { retry } from '@exodus/simple-retry'
-import { simpleErc20 } from '@exodus/solidity-contract'
+import SolidityContract from '@exodus/solidity-contract'
 import { bufferToHex } from '@exodus/ethereumjs-util'
 import { randomUUID } from '@exodus/crypto/randomUUID'
 
@@ -75,7 +75,7 @@ export function create(defaultURL) {
     },
 
     async balanceOf(address, tokenAddress, tag = 'latest') {
-      const contract = simpleErc20(tokenAddress)
+      const contract = SolidityContract.simpleErc20(tokenAddress)
       const callData = contract.balanceOf.build(address)
       const data = {
         data: bufferToHex(callData),

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

@@ -1,20 +1,29 @@
 import assets from '@exodus/assets'
 
 import { fetchTxPreview } from './fetch-tx-preview'
+import { getERC20Params } from '../eth-like-util'
 
-function weiToEth(wei) {
-  const asset = assets.ethereum
-  const currency = asset.currency
+const ethDecimals = assets.ethereum.units.ETH
 
-  const valueInEth = currency.baseUnit(wei).toDefaultString()
+const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
 
-  return valueInEth
-}
+async function getDecimals(type, assetContractAddress = null) {
+  if (type === 'erc20' && assetContractAddress) {
+    const { decimals } = await getERC20Params({
+      address: assetContractAddress,
+      assetName: 'ethereum',
+      paramNames: ['decimals'],
+    })
 
-const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
+    return decimals
+  }
+
+  return ethDecimals
+}
 
-export async function simulateTx(transaction) {
-  let accounts = {}
+export async function simulateAndRetrieveSideEffects(transaction) {
+  const willSend = []
+  const willReceive = []
 
   if (!transaction.to) throw new Error(`'to' field is missing in the TX object`)
 
@@ -38,31 +47,40 @@ export async function simulateTx(transaction) {
       simulatedBalanceChanges.filter(({ address }) => address === transaction.from)
 
     if (sender) {
-      sender.balanceChanges.forEach((balanceChange) => {
-        const delta = balanceChange.delta
+      for (const balanceChange of sender.balanceChanges) {
+        const { delta, asset } = balanceChange
+
+        const decimal = await getDecimals(asset.type, asset.contractAddress)
+
         if (delta.startsWith('-')) {
-          accounts.willSend = {
-            symbol: balanceChange.asset.symbol,
-            amount: weiToEth(delta.slice(1)),
-          }
+          willSend.push({
+            symbol: asset.symbol,
+            balance: delta.slice(1),
+            assetType: asset.type,
+            decimal,
+          })
         } else {
-          accounts.willReceive = {
-            symbol: balanceChange.asset.symbol,
-            amount: weiToEth(delta),
-          }
+          willReceive.push({
+            symbol: asset.symbol,
+            balance: delta,
+            assetType: asset.type,
+            decimal,
+          })
         }
-      })
+      }
     }
 
-    if (!accounts.willSend) {
-      accounts.willSend = {
+    if (!willSend.length) {
+      willSend.push({
         symbol: 'ETH',
-        amount: weiToEth(transaction.value),
-      }
+        balance: ethHexToInt(transaction.value).toString(),
+        assetType: 'ether',
+        decimal: ethDecimals,
+      })
     }
   } catch (_) {
     throw new Error('Simulation of Ethereum transaction failed.')
   }
 
-  return accounts
+  return { willSend, willReceive }
 }

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

@@ -217,18 +217,16 @@ export class EthereumMonitor extends BaseMonitor {
       const { confirmed } = await server.getBalance(ourWalletAddress)
       newAccountState.balance = asset.currency.baseUnit(confirmed.value)
     }
-    const tokenBalances = Object.assign(
-      {},
-      ...(await Promise.all(
-        tokens
-          .filter((token) => isRpcBalanceAsset(token) && token.contract.address)
-          .map(async (token) => {
-            const { confirmed } = await server.balanceOf(ourWalletAddress, token.contract.address)
-            const value = token.currency.baseUnit(confirmed[token.contract.address] || 0)
-            return value.isZero ? {} : { [token.name]: value }
-          })
-      ))
+    const tokenBalancePairs = await Promise.all(
+      tokens
+        .filter((token) => isRpcBalanceAsset(token) && token.contract.address)
+        .map(async (token) => {
+          const { confirmed } = await server.balanceOf(ourWalletAddress, token.contract.address)
+          const value = token.currency.baseUnit(confirmed[token.contract.address] || 0)
+          return value.isZero ? null : [token.name, value]
+        })
     )
+    const tokenBalances = Object.fromEntries(tokenBalancePairs.filter((pair) => pair))
     if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
     return newAccountState
   }