@exodus/ethereum-api 5.1.0-alpha.0 → 6.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "5.1.0-alpha.0",
+  "version": "6.0.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -16,7 +16,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.27.0-alpha.0",
+    "@exodus/ethereum-lib": "^3.0.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/fetch": "^1.2.1",
     "@exodus/simple-retry": "^0.0.6",
@@ -36,5 +36,5 @@
   "devDependencies": {
     "@exodus/models": "^8.10.4"
   },
-  "gitHead": "3241be77078ca4bf456bd7b2e8f3fe545142c92e"
+  "gitHead": "b299a67ebe7a7c23638d868b074df4d20b3f56d9"
 }

package/src/eth-like-util.js

@@ -1,8 +1,8 @@
+import assert from 'minimalistic-assert'
 import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken, ABI } from '@exodus/ethereum-lib'
-import { getServerByName, getServer } from './exodus-eth-server'
 import { memoizeLruCache } from '@exodus/asset-lib'
-import assets from '@exodus/assets'
 import SolidityContract from '@exodus/solidity-contract'
+import { getServerByName, getServer } from './exodus-eth-server'
 
 export async function isContract(baseAssetName, address) {
   return getServerByName(baseAssetName).isContract(address)
@@ -86,18 +86,9 @@ 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}`)
-  }
+export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARAM_NAMES } = {}) => {
+  assert(asset, 'getERC20Params(): asset required')
+  assert(address, 'getERC20Params(): address required')
 
   const cacheKey = `${address}:${paramNames}`
   if (erc20ParamsCache[cacheKey]) {

package/src/index.js

@@ -9,4 +9,3 @@ export * from './tx-log'
 export * from './get-balances'
 export * from './staking'
 export * from './simulate-tx'
-export * from './optimism-gas'

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

@@ -1,4 +1,5 @@
-import assets from '@exodus/assets'
+import assert from 'minimalistic-assert'
+import { asset as ethereum } from '@exodus/ethereum-meta'
 import {
   checkIsERC721InputData,
   checkIsNFTInputData,
@@ -9,14 +10,14 @@ import SolidityContract from '@exodus/solidity-contract'
 import { fetchTxPreview } from './fetch-tx-preview'
 import { getERC20Params } from '../eth-like-util'
 
-const ethDecimals = assets.ethereum.units.ETH
+const ethDecimals = ethereum.units.ETH
 
 const ethHexToInt = (hexValue) => parseInt(hexValue, '16')
 
-async function getAssetSymbolFromContract(contractAddress) {
+async function getAssetSymbolFromContract(contractAddress, asset) {
   const { symbol: assetSymbol } = await getERC20Params({
     address: contractAddress,
-    assetName: 'ethereum',
+    asset,
     paramNames: ['symbol'],
   })
 
@@ -53,12 +54,11 @@ async function prepareBalanceChanges(
   internalTransactions,
   balanceChanges,
   transactionInput,
-  assetName = 'ethereum'
+  asset
 ) {
   const assetNameToSymbolMap = Object.create(null)
   assetNameToSymbolMap['ethereum'] = 'ETH' // Refactor after blowfish integration
 
-  const asset = assets[assetName]
   const preparedBalanceChanges = [...balanceChanges]
 
   const decimals = Object.create(null)
@@ -85,7 +85,7 @@ async function prepareBalanceChanges(
       if (isERC20) {
         const assetSymbol =
           contractCall.contractAlias ||
-          (await getAssetSymbolFromContract(contractCall.contractAddress))
+          (await getAssetSymbolFromContract(contractCall.contractAddress, asset))
 
         assetSymbols[contractCall.contractAddress] = assetSymbol
         decimals[assetSymbol] = contractCall.contractDecimals
@@ -98,40 +98,40 @@ async function prepareBalanceChanges(
   }
 
   for (const balanceChange of preparedBalanceChanges) {
-    const { asset } = balanceChange
+    const { asset: assetData } = balanceChange
 
-    if (!asset.symbol) {
-      asset.symbol =
-        assetSymbols[asset.contractAddress] ||
-        (await getAssetSymbolFromContract(asset.contractAddress))
+    if (!assetData.symbol) {
+      assetData.symbol =
+        assetSymbols[assetData.contractAddress] ||
+        (await getAssetSymbolFromContract(assetData.contractAddress, asset))
     }
 
     if (isERC721) {
-      asset.type = 'erc721'
-      asset.title = contractName
+      assetData.type = 'erc721'
+      assetData.title = contractName
       continue
     }
 
-    if (typeof decimals[asset.symbol] === 'number') {
-      asset.decimal = decimals[asset.symbol]
+    if (typeof decimals[assetData.symbol] === 'number') {
+      assetData.decimal = decimals[assetData.symbol]
       continue
     }
 
-    if (isERC20 && asset.contractAddress) {
+    if (isERC20 && assetData.contractAddress) {
       const { decimals: assetDecimal } = await getERC20Params({
-        address: asset.contractAddress,
-        assetName: 'ethereum',
+        address: assetData.contractAddress,
+        asset,
         paramNames: ['decimals'],
       })
 
-      asset.decimal = assetDecimal
+      assetData.decimal = assetDecimal
     }
   }
 
   return maybeRemoveDuplicates(preparedBalanceChanges)
 }
 
-async function tryToDecodeApprovalTransaction(transaction) {
+async function tryToDecodeApprovalTransaction(transaction, asset) {
   if (!transaction?.data.startsWith(APPROVE_METHOD_ID)) return null
 
   const contract = SolidityContract.erc20(transaction.to)
@@ -142,7 +142,7 @@ async function tryToDecodeApprovalTransaction(transaction) {
     const [grantedTo, balance] = decodedInput.values
 
     const symbol =
-      (await getAssetSymbolFromContract(transaction.to))?.toUpperCase() || 'Unknown Token'
+      (await getAssetSymbolFromContract(transaction.to, asset))?.toUpperCase() || 'Unknown Token'
 
     return [{ grantedTo, balance, symbol, decimals: undefined }] // ToDo: Return 'decimals' in the future once we support changing the approval amount.
   } catch (e) {
@@ -152,11 +152,13 @@ async function tryToDecodeApprovalTransaction(transaction) {
   }
 }
 
-export async function retrieveSideEffects({ transaction, assetName, shouldSimulate = true }) {
+export async function retrieveSideEffects({ transaction, asset, shouldSimulate = true }) {
+  assert(asset, 'retrieveSideEffects(): asset is required')
+
   const willSend = []
   const willReceive = []
 
-  const approveTransactionData = await tryToDecodeApprovalTransaction(transaction)
+  const approveTransactionData = await tryToDecodeApprovalTransaction(transaction, asset)
   if (approveTransactionData) {
     return { willApprove: approveTransactionData }
   }
@@ -192,25 +194,25 @@ export async function retrieveSideEffects({ transaction, assetName, shouldSimula
         internalTransactions,
         sender.balanceChanges,
         transaction.data,
-        assetName
+        asset
       )
 
       for (const balanceChange of preparedBalanceChanges) {
-        const { delta, asset } = balanceChange
+        const { delta, asset: assetData } = balanceChange
 
         const account = {
-          symbol: asset.symbol,
+          symbol: assetData.symbol,
           balance: delta,
-          assetType: asset.type,
-          decimal: asset.decimal,
+          assetType: assetData.type,
+          decimal: assetData.decimal,
         }
 
         if (delta.startsWith('-')) {
           willSend.push(account)
         } else {
-          if (asset.type === 'erc721') {
+          if (assetData.type === 'erc721') {
             account.nft = {
-              title: `${asset.title || asset.symbol} #${delta}`,
+              title: `${assetData.title || assetData.symbol} #${delta}`,
             }
           }
           willReceive.push(account)

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

@@ -8,6 +8,7 @@ import {
   getAllLogItemsByAsset,
   checkPendingTransactions,
   getDeriveTransactionsToCheck,
+  excludeUnchangedTokenBalances,
 } from './monitor-utils'
 import { getLogItemsFromServerTx, getDeriveDataNeededForTick, filterEffects } from './clarity-utils'
 
@@ -158,6 +159,7 @@ export class ClarityMonitor extends BaseMonitor {
 
     const accountState = await this.getNewAccountState({
       tokens,
+      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
       ourWalletAddress: derivedData.ourWalletAddress,
     })
     await this.updateAccountState({
@@ -187,7 +189,7 @@ export class ClarityMonitor extends BaseMonitor {
     }
   }
 
-  async getNewAccountState({ tokens, ourWalletAddress }) {
+  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
     const asset = this.asset
     const newAccountState = {}
     const balances = await this.getBalances({ tokens, ourWalletAddress })
@@ -196,14 +198,15 @@ export class ClarityMonitor extends BaseMonitor {
       newAccountState.balance = asset.currency.baseUnit(balance)
     }
     const tokenBalancePairs = Object.entries(balances).filter((entry) => entry[0] !== asset.name)
-    const entries = tokenBalancePairs
+    const tokenBalanceEntries = tokenBalancePairs
       .map((pair) => {
         const token = tokens.find((token) => token.name === pair[0])
         const value = token.currency.baseUnit(pair[1] || 0)
-        return value.isZero ? null : [token.name, value]
+        return [token.name, value]
       })
       .filter((pair) => pair)
-    const tokenBalances = Object.fromEntries(entries)
+
+    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalanceEntries)
     if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
     return newAccountState
   }

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

@@ -11,6 +11,7 @@ import {
   getDeriveDataNeededForTick,
   getDeriveTransactionsToCheck,
   getHistoryFromServer,
+  excludeUnchangedTokenBalances,
 } from './monitor-utils'
 
 import {
@@ -185,8 +186,10 @@ export class EthereumMonitor extends BaseMonitor {
 
     const accountState = await this.getNewAccountState({
       tokens,
+      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
       ourWalletAddress: derivedData.ourWalletAddress,
     })
+
     await this.updateAccountState({ newData: { index, ...accountState }, walletAccount })
 
     await this.removeFromTxLog(txsToRemove)
@@ -220,7 +223,7 @@ export class EthereumMonitor extends BaseMonitor {
     }
   }
 
-  async getNewAccountState({ tokens, ourWalletAddress }) {
+  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
     const asset = this.asset
     const newAccountState = {}
     const server = this.server
@@ -236,10 +239,11 @@ export class EthereumMonitor extends BaseMonitor {
         .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]
+          return [token.name, value]
         })
     )
-    const tokenBalances = Object.fromEntries(tokenBalancePairs.filter((pair) => pair))
+
+    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalancePairs)
     if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
     return newAccountState
   }

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

@@ -3,7 +3,11 @@ import { getServer } from '@exodus/ethereum-api'
 import { DEFAULT_SERVER_URLS } from '@exodus/ethereum-lib'
 import { Tx } from '@exodus/models'
 
-import { getDeriveDataNeededForTick, getDeriveTransactionsToCheck } from './monitor-utils'
+import {
+  getDeriveDataNeededForTick,
+  getDeriveTransactionsToCheck,
+  excludeUnchangedTokenBalances,
+} from './monitor-utils'
 
 import { isEmpty, unionBy, zipObject } from 'lodash'
 
@@ -57,21 +61,22 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     return Object.fromEntries(entries)
   }
 
-  async getNewAccountState({ tokens, ourWalletAddress }) {
+  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
     const asset = this.asset
     const newAccountState = {}
     const balances = await this.getBalances({ tokens, ourWalletAddress })
     const balance = balances[asset.name]
     newAccountState.balance = asset.currency.baseUnit(balance)
     const tokenBalancePairs = Object.entries(balances).filter((entry) => entry[0] !== asset.name)
-    const entries = tokenBalancePairs
+    const tokenBalanceEntries = tokenBalancePairs
       .map((pair) => {
         const token = tokens.find((token) => token.name === pair[0])
         const value = token.currency.baseUnit(pair[1] || 0)
-        return value.isZero ? null : [token.name, value]
+        return [token.name, value]
       })
       .filter((pair) => pair)
-    const tokenBalances = Object.fromEntries(entries)
+
+    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalanceEntries)
     if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
     return newAccountState
   }
@@ -79,7 +84,11 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
   async deriveData({ assetSource, tokens }) {
     const { assetName, walletAccount } = assetSource
 
-    const { ourWalletAddress } = await this.deriveDataNeededForTick({ assetName, walletAccount })
+    const { ourWalletAddress, currentAccountState } = await this.deriveDataNeededForTick({
+      assetName,
+      walletAccount,
+    })
+
     const {
       pendingTransactionsGroupedByAddressAndNonce,
       pendingTransactionsToCheck,
@@ -96,7 +105,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
       'tx.txId'
     )
 
-    return { ourWalletAddress, pendingTransactions }
+    return { ourWalletAddress, pendingTransactions, currentAccountState }
   }
 
   async getTransactionsFromNode(transactions) {
@@ -148,7 +157,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
 
     const assetSource = { assetName: this.asset.name, walletAccount }
 
-    const { ourWalletAddress, pendingTransactions } = await this.deriveData({
+    const { ourWalletAddress, pendingTransactions, currentAccountState } = await this.deriveData({
       assetSource,
       tokens,
     })
@@ -171,6 +180,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
 
     const accountState = await this.getNewAccountState({
       tokens,
+      currentTokenBalances: currentAccountState?.tokenBalances,
       ourWalletAddress,
     })
 

package/src/tx-log/monitor-utils/exclude-unchanged-token-balances.js

@@ -0,0 +1,13 @@
+export function excludeUnchangedTokenBalances(currentTokenBalances, newTokenBalancePairs) {
+  const newTokenBalances = Object.fromEntries(newTokenBalancePairs)
+
+  const tokenBalances = newTokenBalancePairs.reduce((tokenBalancesAcc, [token, balance]) => {
+    const currentBalance = currentTokenBalances[token]
+    if (!newTokenBalances[token].isZero || (currentBalance && !currentBalance.isZero)) {
+      tokenBalancesAcc[token] = balance
+    }
+    return tokenBalancesAcc
+  }, {})
+
+  return tokenBalances
+}

package/src/tx-log/monitor-utils/get-log-items-from-server-tx.js

@@ -41,8 +41,9 @@ export default function getLogItemsFromServerTx({
   {
     const sendingTransferPresent = ethereumTransfers.some(({ from }) => from === ourWalletAddress)
     const receivingTransferPresent = ethereumTransfers.some(({ to }) => to === ourWalletAddress)
+    const nftTransferPresent = isNftTransfer({ serverTx, ourWalletAddress })
 
-    if (sendingTransferPresent || receivingTransferPresent) {
+    if (sendingTransferPresent || receivingTransferPresent || nftTransferPresent) {
       const coinAmount = getValueOfTransfers(ourWalletAddress, asset, ethereumTransfers)
       const selfSend = isSelfSendTx({
         coinAmount,
@@ -140,3 +141,11 @@ function isSelfSendTx({
     coinAmount.isZero && sendingTransferPresent && receivingTransferPresent && ourWalletWasSender
   )
 }
+
+function isNftTransfer({ serverTx, ourWalletAddress }) {
+  if (!Array.isArray(serverTx.erc721) || serverTx.erc721.length < 1) return false
+
+  return serverTx.erc721.some(
+    (transfer) => transfer.to === ourWalletAddress || transfer.from === ourWalletAddress
+  )
+}

package/src/tx-log/monitor-utils/index.js

@@ -1,8 +1,10 @@
 export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick'
+
 export { default as getAllLogItemsByAsset } from './get-all-log-items-by-asset'
 export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx'
 export { default as getHistoryFromServer } from './get-history-from-server'
 export { default as checkPendingTransactions } from './check-pending-transactions'
 export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check'
+export * from './exclude-unchanged-token-balances'
 
 export type { PendingTransactionsDictionary } from './types'

package/src/optimism-gas/addresses.js

@@ -1 +0,0 @@
-export const GAS_ORACLE_ADDRESS = '0x420000000000000000000000000000000000000F'

package/src/optimism-gas/index.js

@@ -1,16 +0,0 @@
-import * as ethUtil from '@exodus/ethereumjs-util'
-import { convertUnsignedTx, createContract } from '@exodus/ethereum-lib'
-import { getServerByName } from '../exodus-eth-server'
-import { GAS_ORACLE_ADDRESS } from './addresses'
-
-const gasContract = createContract(GAS_ORACLE_ADDRESS, 'optimismGasOracle')
-
-export async function estimateOptimismL1DataFee({ unsignedTx }) {
-  const ethjsTx = convertUnsignedTx(unsignedTx)
-  const serialized = ethjsTx.serialize()
-  const callData = gasContract.getL1Fee.build(serialized)
-  const buffer = Buffer.from(callData)
-  const data = ethUtil.bufferToHex(buffer)
-  const server = getServerByName('optimism')
-  return server.ethCall({ to: GAS_ORACLE_ADDRESS, data }, 'latest')
-}