@exodus/ethereum-api 7.2.1 → 7.3.1

package/src/index.js

@@ -11,3 +11,6 @@ export * from './staking'
 export * from './simulate-tx'
 export * from './allowance'
 export * from './optimism-gas'
+export * from './number-utils'
+export { txSendFactory, getFeeInfo } from './tx-send'
+export { createAssetFactory } from './create-asset'

package/src/number-utils.js

@@ -0,0 +1,8 @@
+export function fromHexToString(value) {
+  return fromHexToBigInt(value).toString()
+}
+
+export function fromHexToBigInt(value) {
+  const hex = value.startsWith('0x') ? value : '0x' + value
+  return BigInt(hex)
+}

package/src/optimism-gas/index.js

@@ -1,8 +1,8 @@
-import BN from 'bn.js'
 import * as ethUtil from '@exodus/ethereumjs-util'
 import { createEthereumJsTx, createContract } from '@exodus/ethereum-lib'
 import { getServerByName } from '../exodus-eth-server'
 import { GAS_ORACLE_ADDRESS } from './addresses'
+import { fromHexToBigInt } from '../number-utils'
 
 const gasContract = createContract(GAS_ORACLE_ADDRESS, 'optimismGasOracle')
 
@@ -14,8 +14,8 @@ export async function estimateOptimismL1DataFee({ unsignedTx }) {
   const data = ethUtil.bufferToHex(buffer)
   const server = getServerByName('optimism')
   const hex = await server.ethCall({ to: GAS_ORACLE_ADDRESS, data }, 'latest')
-  const l1DataFee = new BN(hex.slice(2), 16)
-  const padFee = l1DataFee.div(new BN(4, 10))
-  const maxL1DataFee = l1DataFee.add(padFee)
+  const l1DataFee = fromHexToBigInt(hex)
+  const padFee = l1DataFee / BigInt(4)
+  const maxL1DataFee = l1DataFee + padFee
   return maxL1DataFee.toString()
 }

package/src/staking/ethereum/service.js

@@ -1,9 +1,9 @@
 import { estimateGasLimit } from '../../gas-estimation'
 import { getServer } from '../../exodus-eth-server'
 import { isNumberUnit } from '@exodus/currency'
-import BN from 'bn.js'
 import { stakingProviderClientFactory } from '../staking-provider-client'
 import { EthereumStaking } from './api'
+import { fromHexToBigInt } from '../../number-utils'
 
 const extraGasLimit = 20_000 // extra gas Limit to prevent tx failing if something change on pool state (till tx is in mempool)
 
@@ -233,12 +233,12 @@ export function createEthereumStakingService({
       gasPrice = await getServer(asset).gasPrice()
     }
 
-    gasPrice = parseInt(gasPrice, 16)
-    const fee = new BN(gasPrice).mul(new BN(gasLimit + extraGasLimit))
+    gasPrice = fromHexToBigInt(gasPrice)
+    const fee = gasPrice * BigInt(gasLimit + extraGasLimit)
 
     return {
       gasLimit,
-      gasPrice: asset.currency.baseUnit(gasPrice),
+      gasPrice: asset.currency.baseUnit(gasPrice.toString()),
       fee: asset.currency.baseUnit(fee.toString()),
     }
   }

package/src/staking-api.js

@@ -0,0 +1,5 @@
+export function createStakingApi({ network }) {
+  return {
+    isStaking: ({ accountState }) => accountState.staking[network]?.isDelegating,
+  }
+}

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

@@ -1,4 +1,3 @@
-import BN from 'bn.js'
 import { BaseMonitor } from '@exodus/asset-lib'
 import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
 import { isEmpty } from 'lodash'
@@ -10,6 +9,7 @@ import {
   excludeUnchangedTokenBalances,
 } from './monitor-utils'
 import { getLogItemsFromServerTx, getDeriveDataNeededForTick, filterEffects } from './clarity-utils'
+import { fromHexToString } from '../number-utils'
 
 export class ClarityMonitor extends BaseMonitor {
   constructor({ server, config, ...args }) {
@@ -250,8 +250,7 @@ export class ClarityMonitor extends BaseMonitor {
     const entries = pairs.map((pair, idx) => {
       const balanceHex = responses[idx]
       const name = pair[0]
-      const hex = balanceHex.startsWith('0x') ? balanceHex.slice(2) : balanceHex
-      const balance = new BN(hex, 'hex').toString()
+      const balance = fromHexToString(balanceHex)
       return [name, balance]
     })
     return Object.fromEntries(entries)
@@ -273,13 +272,9 @@ export class ClarityMonitor extends BaseMonitor {
 
   async updateGasPrice({ gasPrice, baseFeePerGas }) {
     try {
-      const gasPriceHex = gasPrice?.startsWith('0x') ? gasPrice.slice(2) : gasPrice
-      const feeConfig = { gasPrice: `${new BN(gasPriceHex, 'hex').toString()} wei` }
+      const feeConfig = { gasPrice: `${fromHexToString(gasPrice).toString()} wei` }
       if (baseFeePerGas) {
-        const baseFeePerGasHex = baseFeePerGas?.startsWith('0x')
-          ? baseFeePerGas.slice(2)
-          : baseFeePerGas
-        feeConfig.baseFeePerGas = `${new BN(baseFeePerGasHex, 'hex').toString()} wei`
+        feeConfig.baseFeePerGas = `${fromHexToString(baseFeePerGas)} wei`
       }
 
       this.logger.debug(

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

@@ -1,4 +1,3 @@
-import BN from 'bn.js'
 import { getServer } from '../exodus-eth-server'
 import { isRpcBalanceAsset, getAssetAddresses } from '@exodus/ethereum-lib'
 
@@ -21,6 +20,7 @@ import {
 import { isEmpty } from 'lodash'
 
 import { BaseMonitor } from '@exodus/asset-lib'
+import { fromHexToString } from '../number-utils'
 
 // The base ethereum monitor class handles listening for, fetching,
 // formatting, and populating-to-state all ETH/ETC/ERC20 transactions.
@@ -211,8 +211,7 @@ export class EthereumMonitor extends BaseMonitor {
     const server = this.server
     if (isRpcBalanceAsset(asset)) {
       const result = await server.getBalanceProxied(ourWalletAddress)
-      const hex = result.startsWith('0x') ? result.slice(2) : result
-      const balance = new BN(hex, 'hex').toString()
+      const balance = fromHexToString(result)
       newAccountState.balance = asset.currency.baseUnit(balance)
     }
 

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

@@ -1,4 +1,3 @@
-import BN from 'bn.js'
 import { getServer } from '../exodus-eth-server'
 import { DEFAULT_SERVER_URLS } from '@exodus/ethereum-lib'
 import { Tx } from '@exodus/models'
@@ -14,6 +13,7 @@ import { isEmpty, unionBy, zipObject } from 'lodash'
 import { BaseMonitor } from '@exodus/asset-lib'
 
 import { UNCONFIRMED_TX_LIMIT } from './monitor-utils/get-derive-transactions-to-check'
+import { fromHexToString } from '../number-utils'
 
 // The base ethereum monitor no history class handles listening for assets with no history
 
@@ -57,8 +57,7 @@ export class EthereumNoHistoryMonitor extends BaseMonitor {
     const entries = pairs.map((pair, idx) => {
       const balanceHex = responses[idx]
       const name = pair[0]
-      const hex = balanceHex.startsWith('0x') ? balanceHex.slice(2) : balanceHex
-      const balance = new BN(hex, 'hex').toString()
+      const balance = fromHexToString(balanceHex)
       return [name, balance]
     })
     return Object.fromEntries(entries)

package/src/tx-log-staking-processor/asset-staking-tx-data.js

@@ -0,0 +1,48 @@
+import {
+  isEthereumClaimUndelegate,
+  isEthereumDelegate,
+  isEthereumUndelegate,
+  isEthereumUndelegatePending,
+} from '../staking/ethereum/staking-utils'
+
+import { isPolygonClaimUndelegate, isPolygonDelegate } from '../staking/matic'
+
+import {
+  decodePolygonStakingTxInputAmount,
+  isEthereumTxCountedForRewards,
+  isEthereumUndelegateTx,
+} from './utils.js'
+
+const getEthereumStakeTxType = ({ tx }) => {
+  // only unstake txs with ZERO amount are used to calculate rewards
+  const skipTx = tx.coinAmount.isZero && !isEthereumUndelegateTx(tx)
+  if (skipTx) return
+
+  if (isEthereumDelegate(tx)) return { delegate: tx.coinAmount.toDefaultString() }
+  // undelegate must be taken in consideration, if unstaked ETH is still
+  // in the pool queue, undelgate transfers staked funds back inmediatly to the user
+  if (isEthereumUndelegatePending(tx)) return { undelegatePending: tx.coinAmount.toDefaultString() }
+  if (isEthereumUndelegate(tx) && !isEthereumTxCountedForRewards(tx))
+    return { undelegate: tx.coinAmount.toDefaultString() }
+  // In the case of the ETH being actually staked and earning,
+  // unstake has a withdraw period, after that, unstaked can be claimed.
+  if (isEthereumClaimUndelegate(tx) && !isEthereumTxCountedForRewards(tx))
+    return { claimUndelegate: tx.coinAmount.toDefaultString() }
+}
+
+const getPolygonStakeTxType = ({ tx, currency }) => {
+  if (tx.coinAmount.isZero) return
+
+  if (isPolygonDelegate(tx)) {
+    const stakeTxAmount = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
+    return { delegate: stakeTxAmount }
+  }
+
+  if (isPolygonClaimUndelegate(tx)) return { undelegate: tx.coinAmount.toDefaultString() }
+}
+
+export const assetStakingTxData = {
+  polygon: getPolygonStakeTxType,
+  ethereum: getEthereumStakeTxType,
+  ethereumholesky: getEthereumStakeTxType,
+}

package/src/tx-log-staking-processor/derive-txs.js

@@ -0,0 +1,59 @@
+import { decodeEthLikeStakingTxInputAmount } from './utils'
+
+const deriveEthereumTxs = ({ currency }) => {
+  let totalUnstaked = currency.ZERO
+
+  return function ({ tx, txStakeData }) {
+    const { claimUndelegate, undelegate } = txStakeData
+
+    if (claimUndelegate && totalUnstaked.isPositive) {
+      // calculate and add a new reward tx based 'totalUnstaked' (unstaked amount counted so far)
+      const claimedWithRewards = currency.defaultUnit(claimUndelegate)
+      const reward = claimedWithRewards.sub(totalUnstaked)
+      const claimed = claimedWithRewards.sub(reward)
+      // count again for new rewards in upcoming unstake txs
+      totalUnstaked = currency.ZERO
+      return reward.isPositive
+        ? [
+            {
+              ...tx,
+              coinAmount: reward,
+              data: {
+                reward: reward.toDefaultString(),
+                claim: claimed.toDefaultString(),
+                countedForRewards: true,
+              },
+            },
+          ]
+        : []
+    }
+
+    if (undelegate) {
+      // Only care about amount requested in 'unstake()'; considered to be in progress.
+      // Counting unstake (not unstake pending) amount until 'claimUnstake()' is called,
+      // then use the counted unstaked amount to derive rewards with:
+      //    rewards = claimUstaked - totalUnstaked
+      const unstakeInProgress = currency.baseUnit(decodeEthLikeStakingTxInputAmount(tx))
+      totalUnstaked = totalUnstaked.add(unstakeInProgress)
+      return [
+        {
+          ...tx,
+          coinAmount: currency.ZERO,
+          data: { ...tx.data, countedForRewards: true },
+        },
+      ]
+    }
+
+    // undelegate pending excluded as unstaked funds are moved inmediatly to user address
+    return []
+  }
+}
+
+export const deriveAssetTxsFactory = ({ assetName, currency }) => {
+  const deriveTxHandlers = {
+    ethereum: deriveEthereumTxs({ currency }),
+    ethereumholesky: deriveEthereumTxs({ currency }),
+  }
+
+  return deriveTxHandlers[assetName]
+}

package/src/tx-log-staking-processor/get-asset-tx-amount.js

@@ -0,0 +1,26 @@
+import { calculateTxAmountAndRewardFromStakeTx } from './utils.js'
+
+const getPolygonTxAmount = ({ currency, tx, type }) => {
+  if ('delegate' in type) {
+    return calculateTxAmountAndRewardFromStakeTx({ tx, currency })
+  }
+
+  return currency.ZERO
+}
+
+const getEthereumTxAmount = ({ currency, tx, type }) => {
+  const isStakingTx = ['delegate', 'undelegatePending', 'undelegate', 'claimUndelegate'].some(
+    (stakingType) => type[stakingType]
+  )
+  if (isStakingTx) {
+    return currency.ZERO
+  }
+
+  return tx.coinAmount
+}
+
+export const getStakeTxAmount = {
+  polygon: getPolygonTxAmount,
+  ethereum: getEthereumTxAmount,
+  ethereumholesky: getEthereumTxAmount,
+}

package/src/tx-log-staking-processor/index.js

@@ -0,0 +1,36 @@
+import { assetStakingTxData } from './asset-staking-tx-data'
+import { deriveAssetTxsFactory } from './derive-txs'
+import { getStakeTxAmount } from './get-asset-tx-amount'
+
+const getTxStakeData = ({ assetName, currency, tx }) => {
+  return assetStakingTxData[assetName]({ tx, currency })
+}
+
+const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, batch }) => {
+  const { name: assetName, currency } = asset
+  const txs = await aci.getTxLog({ assetName, walletAccount })
+  const deriveAssetTxs = deriveAssetTxsFactory({ assetName, currency })
+
+  const newTxs = []
+  for (const tx of txs) {
+    const txStakeData = getTxStakeData({ assetName, currency, tx })
+    if (txStakeData) {
+      const txAmount = getStakeTxAmount[assetName]({ tx, currency, type: txStakeData })
+      newTxs.push({
+        ...tx,
+        coinAmount: txAmount,
+        data: { ...tx.data, ...txStakeData },
+      })
+    }
+
+    if (txStakeData && deriveAssetTxs) {
+      newTxs.push(...deriveAssetTxs({ tx, txStakeData }))
+    }
+  }
+
+  if (newTxs.length > 0) {
+    aci.updateTxLogAndNotifyBatch({ assetName, walletAccount, txs: newTxs, batch })
+  }
+}
+
+export default processTxLog

package/src/tx-log-staking-processor/utils.js

@@ -0,0 +1,70 @@
+import { EthereumStaking, isEthereumStakingTx, MaticStakingApi } from '../staking'
+import { asset as ethereum } from '@exodus/ethereum-meta'
+import { asset as ethereumholesky } from '@exodus/ethereumholesky-meta'
+
+const polygonStakingApi = new MaticStakingApi()
+const ethereumStakingApi = new EthereumStaking(ethereum)
+const ethereumHoleskyStakingApi = new EthereumStaking(ethereumholesky)
+
+export const decodePolygonStakingTxInputAmount = (tx) => {
+  const {
+    data: { data: txInput },
+  } = tx
+
+  const {
+    values: [amount], // stake or unstake amount
+  } = polygonStakingApi.validatorShareContract.decodeInput(txInput)
+
+  return amount
+}
+
+export const calculateTxAmountAndRewardFromStakeTx = ({ tx, currency }) => {
+  const stakedAmount = currency.baseUnit(decodePolygonStakingTxInputAmount(tx))
+  const { reward } = tx.data
+  // stake tx might have rewards in it,
+  // i.e: https://etherscan.io/tx/0x0a81d266109034a3a70c6f1b9601c105d8caebbd0de652a0619344f9559ae4fa
+  // thus reward = txInputAmount(amount to stake) - tx.coinAmount
+  // tx.coinAmount is already computed from monitor; incoming - outgoing ERC20 token txs
+  const stakeTxContainsReward = !stakedAmount.equals(tx.coinAmount.abs())
+
+  if (reward) {
+    // cache rewards
+    return currency.baseUnit(reward)
+  }
+
+  if (stakeTxContainsReward) {
+    const txAmount = stakedAmount.sub(tx.coinAmount.abs()).abs()
+    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only -- TODO: Fix this the next time the file is edited.
+    tx.data.reward = txAmount.toBaseString()
+    return txAmount
+  }
+
+  // no rewards, set stake tx amount to ZERO
+  return currency.ZERO
+}
+
+export const decodeEthLikeStakingTxInputAmount = (tx) => {
+  const {
+    data: { data: txInput },
+    coinName: assetName,
+  } = tx
+
+  const ethereumLikeContracts = {
+    ethereum: ethereumStakingApi,
+    ethereumholesky: ethereumHoleskyStakingApi,
+  }
+
+  const ethLikeContract = ethereumLikeContracts[assetName]
+
+  const {
+    values: [amount], // stake or unstake amount
+  } = ethLikeContract.contractPool.decodeInput(txInput)
+
+  return amount
+}
+
+// TODO: fix this in eth libraries
+export const isEthereumUndelegateTx = (tx) =>
+  isEthereumStakingTx(tx) && tx.data?.methodId === EthereumStaking.METHODS_IDS.UNSTAKE
+
+export const isEthereumTxCountedForRewards = (tx) => !!tx.data?.countedForRewards

package/src/tx-send/get-fee-info.js

@@ -0,0 +1,41 @@
+import { fetchGasLimit } from '../gas-estimation'
+
+const getFeeInfo = async function getFeeInfo({
+  assetClientInterface,
+  asset,
+  fromAddress,
+  toAddress,
+  amount,
+  isExchange,
+  txInput,
+  feeOpts = {},
+}) {
+  const {
+    gasPrice: gasPrice_,
+    tipGasPrice: tipGasPrice_,
+    gasPriceEconomicalRate,
+  } = await assetClientInterface.getFeeData({
+    assetName: asset.name,
+  })
+
+  let { gasLimit, gasPrice = gasPrice_, tipGasPrice = tipGasPrice_ } = feeOpts
+
+  if (!gasLimit) {
+    gasLimit = await fetchGasLimit({
+      asset,
+      fromAddress,
+      toAddress,
+      amount,
+      txInput,
+      throwOnError: false,
+      isContract: feeOpts.isContract ?? undefined,
+    })
+  }
+
+  const economicalFeeMultiplier = isExchange ? 1 : gasPriceEconomicalRate || 1
+
+  const fee = gasPrice.mul(economicalFeeMultiplier).mul(gasLimit)
+  return { gasPrice, gasLimit, fee, tipGasPrice }
+}
+
+export default getFeeInfo

package/src/tx-send/index.js

@@ -0,0 +1,2 @@
+export { default as txSendFactory } from './tx-send'
+export { default as getFeeInfo } from './get-fee-info'