@exodus/ethereum-api 2.19.0 → 2.20.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.19.0",
+  "version": "2.20.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -29,5 +29,5 @@
     "@exodus/assets-base": "^8.0.136",
     "@exodus/models": "^8.7.2"
   },
-  "gitHead": "de6258fcd05409586558bbffff54c2c2a3c065b1"
+  "gitHead": "f6ffc7e8100b7b1b85d2c7b30cce4aa2b251cab3"
 }

package/src/eth-like-util.js

@@ -134,13 +134,7 @@ export const getERC20Params = async ({
     })
   )
 
-  const response = paramNames.reduce(
-    (accumulatedObj, paramName, index) => ({
-      ...accumulatedObj,
-      [paramName]: paramValues[index],
-    }),
-    {}
-  )
+  const response = Object.fromEntries(paramNames.map((paramName, index) => ([paramName, paramValues[index]])))
   erc20ParamsCache[cacheKey] = response
 
   return response

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

@@ -7,18 +7,40 @@ const ethDecimals = assets.ethereum.units.ETH
 
 const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
 
-async function getDecimals(type, assetContractAddress = null) {
-  if (type === 'erc20' && assetContractAddress) {
-    const { decimals } = await getERC20Params({
-      address: assetContractAddress,
-      assetName: 'ethereum',
-      paramNames: ['decimals'],
-    })
-
-    return decimals
+async function getDecimalsFromSimulatedTx(internalTransactions, balanceChanges) {
+  const decimals = {}
+
+  if (internalTransactions && Array.isArray(internalTransactions)) {
+    for (const transaction of internalTransactions) {
+      const { contractCall } = transaction
+
+      if (!contractCall) continue
+
+      if (contractCall.methodName === 'transfer' || contractCall.methodName === 'transferFrom') {
+        decimals[contractCall.contractAlias] = contractCall.contractDecimals
+      }
+    }
   }
 
-  return ethDecimals
+  for (const balanceChange of balanceChanges) {
+    const { asset } = balanceChange
+
+    if (typeof decimals[asset.symbol] === 'number') {
+      continue
+    }
+
+    if (asset.type === 'erc20' && asset.contractAddress) {
+      const { decimals: assetDecimal } = await getERC20Params({
+        address: asset.contractAddress,
+        assetName: 'ethereum',
+        paramNames: ['decimals'],
+      })
+
+      decimals[asset.symbol] = assetDecimal
+    }
+  }
+
+  return decimals
 }
 
 export async function simulateAndRetrieveSideEffects(transaction) {
@@ -41,31 +63,29 @@ export async function simulateAndRetrieveSideEffects(transaction) {
     const simulatedTx = await fetchTxPreview(blocknativeTxObject)
 
     const [simulatedBalanceChanges] = simulatedTx.netBalanceChanges
+    const [internalTransactions] = simulatedTx.internalTransactions
 
     const [sender] =
       simulatedBalanceChanges &&
       simulatedBalanceChanges.filter(({ address }) => address === transaction.from)
 
     if (sender) {
+      const decimals = await getDecimalsFromSimulatedTx(internalTransactions, sender.balanceChanges)
+
       for (const balanceChange of sender.balanceChanges) {
         const { delta, asset } = balanceChange
 
-        const decimal = await getDecimals(asset.type, asset.contractAddress)
+        const account = {
+          symbol: asset.symbol,
+          balance: delta,
+          assetType: asset.type,
+          decimal: decimals[asset.symbol],
+        }
 
         if (delta.startsWith('-')) {
-          willSend.push({
-            symbol: asset.symbol,
-            balance: delta.slice(1),
-            assetType: asset.type,
-            decimal,
-          })
+          willSend.push(account)
         } else {
-          willReceive.push({
-            symbol: asset.symbol,
-            balance: delta,
-            assetType: asset.type,
-            decimal,
-          })
+          willReceive.push(account)
         }
       }
     }
@@ -73,13 +93,13 @@ export async function simulateAndRetrieveSideEffects(transaction) {
     if (!willSend.length) {
       willSend.push({
         symbol: 'ETH',
-        balance: ethHexToInt(transaction.value).toString(),
+        balance: `-${ethHexToInt(transaction.value)}`,
         assetType: 'ether',
         decimal: ethDecimals,
       })
     }
-  } catch (_) {
-    throw new Error('Simulation of Ethereum transaction failed.')
+  } catch (err) {
+    throw new Error(err)
   }
 
   return { willSend, willReceive }