@exodus/ethereum-api 8.9.1 → 8.9.2

package/CHANGELOG.md

@@ -3,11 +3,23 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.9.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.9.1...@exodus/ethereum-api@8.9.2) (2024-07-03)
+
+### Code Refactoring
+
+* **ethereum:** EVM balances ([#2598](https://github.com/ExodusMovement/assets/issues/2598)) ([fb6b937](https://github.com/ExodusMovement/assets/commit/fb6b9375675494592b42a9c7ce1ccfa505bc8946))
+
+
 ## [8.9.1](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.9.0...@exodus/ethereum-api@8.9.1) (2024-07-03)
 
-**Note:** Version bump only for package @exodus/ethereum-api
+### Features
+
+* patterns for filtering sensitive hint in EthLikeError ([#2721](https://github.com/ExodusMovement/assets/issues/2721)) ([7de766c](https://github.com/ExodusMovement/assets/commit/7de766c20a85168bb11117234ceab4475b26af10))
 
 
+### Bug Fixes
+
+* update SOL staking info on balance change ([#2672](https://github.com/ExodusMovement/assets/issues/2672)) ([bc2043c](https://github.com/ExodusMovement/assets/commit/bc2043ce226128d3e321937a325e20382f12f874))
 
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.9.1",
+  "version": "8.9.2",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -66,5 +66,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "d52d315260d32e7a2fce15e32e7393813a02bc90"
+  "gitHead": "aeda2367cf089f8ac0c1a98fc104d04d995328b9"
 }

package/src/get-balances.js

@@ -24,6 +24,38 @@ const getUnstaked = ({ accountState, asset }) => {
   )
 }
 
+/**
+ * Calculates amount received in staking txs from txLog
+ * Staking txs are counted based in the amount received in the tx (tx.coinAmount)
+ * It can be different from staked / unstaked / claimed requested amount)
+ *
+ * Unstaked tx.coinAmount - Staked tx.coinAmount + Claimed tx.coinAmount
+ *
+ * Depending on the asset, is what tx.coinAmount is:
+ *
+ * Ethereum: for unstake txs, it's unknown how much of it are rewards and unstaked received (full or partial)
+ * Polygon: rewards are transferred in stake and unstake txs
+ */
+export const getStakingHistoryBalance = ({ asset, txLog }) => {
+  let stakingHistoryBalance = asset.currency.ZERO
+  for (const tx of txLog) {
+    const successfulTx = tx.confirmations && !tx.failed
+    if (successfulTx && tx.data?.txAmount) {
+      // only staking txs have tx.data.txAmount set
+      // tx.data.txAmount is negative for stake tx type
+      const txAmount = asset.currency.defaultUnit(tx.data.txAmount)
+      stakingHistoryBalance = stakingHistoryBalance.add(txAmount)
+    }
+  }
+
+  return stakingHistoryBalance
+}
+
+const getSpendable = ({ asset, balance, txLog, unconfirmedReceived }) => {
+  const stakingHistoryBalance = getStakingHistoryBalance({ asset, txLog })
+  return balance.add(stakingHistoryBalance).sub(unconfirmedReceived)
+}
+
 /**
  * Api method to return the balance based on either account state balances or tx history.
  *
@@ -38,21 +70,28 @@ export const getBalancesFactory = ({ monitorType }) => {
     const unconfirmedReceived = getUnconfirmedReceivedBalance({ asset, txLog })
     const unconfirmedSent = getUnconfirmedSentBalance({ asset, txLog })
 
-    // balance from txLog / rpc is considered to be total
-    const balanceWithoutUnconfirmedSent =
-      monitorType === 'no-history' || isRpcBalanceAsset(asset)
-        ? getBalanceFromAccountState({ asset, accountState }).sub(unconfirmedSent)
-        : getBalanceFromTxLog({ txLog, asset })
-
     const staked = getStaked({ asset, accountState })
     const unstaking = getUnstaking({ asset, accountState })
     const unstaked = getUnstaked({ asset, accountState })
-    const total = balanceWithoutUnconfirmedSent
-    const spendable = balanceWithoutUnconfirmedSent
-      .sub(unconfirmedReceived)
-      .sub(staked)
-      .sub(unstaking)
-      .sub(unstaked)
+
+    let total
+    let spendable
+
+    // Balance from accountState is considered total b/c is fetched from rpc
+    if (isRpcBalanceAsset(asset) || monitorType === 'no-history') {
+      total = getBalanceFromAccountState({ asset, accountState }).sub(unconfirmedSent)
+      spendable = total.sub(staked).sub(unstaking).sub(unstaked).sub(unconfirmedReceived)
+    } else {
+      // Balance from txLog does not include staking rewards
+      // spendable and total are calculated differently based on staking txs
+      spendable = getSpendable({
+        asset,
+        balance: getBalanceFromTxLog({ txLog, asset }),
+        txLog,
+        unconfirmedReceived,
+      })
+      total = spendable.add(unconfirmedReceived).add(staked).add(unstaking).add(unstaked)
+    }
 
     return {
       // new

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

@@ -5,53 +5,79 @@ import {
   isEthereumUndelegatePending,
 } from '../staking/ethereum/staking-utils'
 
-import { isPolygonClaimUndelegate, isPolygonDelegate } from '../staking/matic'
+import { isPolygonClaimUndelegate, isPolygonDelegate, isPolygonUndelegate } from '../staking/matic'
 
-import { decodePolygonStakingTxInputAmount } from './utils.js'
+import {
+  decodePolygonStakingTxInputAmount,
+  decodeEthLikeStakingTxInputAmount,
+  calculateRewardsFromStakeTx,
+} from './utils.js'
 
-const getEthereumStakeTxType = ({ tx }) => {
+const getEthereumStakingTxData = ({ tx, currency }) => {
   if (
     ['delegate', 'undelegatePending', 'undelegate', 'claimUndelegate'].some(
       (stakeTx) => tx.data?.[stakeTx]
-    )
+    ) &&
+    tx.coinAmount.isZero
   )
     return
 
+  const txAmount = tx.coinAmount.toDefaultString()
+
   if (isEthereumDelegate(tx)) {
-    return { delegate: tx.coinAmount.toDefaultString() }
+    return { delegate: txAmount, txAmount }
   }
 
   // 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))
+  if (isEthereumUndelegatePending(tx)) {
+    const undelegatePending = currency
+      .baseUnit(decodeEthLikeStakingTxInputAmount(tx))
+      .toDefaultString()
     return {
-      undelegatePending: tx.coinAmount.toDefaultString(),
+      undelegatePending,
+      txAmount,
     }
+  }
 
   if (isEthereumUndelegate(tx)) {
-    return { undelegate: tx.coinAmount.toDefaultString() }
+    const undelegate = currency.baseUnit(decodeEthLikeStakingTxInputAmount(tx)).toDefaultString()
+    return { undelegate, txAmount }
   }
 
   // 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)) {
-    return { claimUndelegate: tx.coinAmount.toDefaultString() }
+    return { claimUndelegate: txAmount, txAmount }
   }
 }
 
-const getPolygonStakeTxType = ({ tx, currency }) => {
-  if (tx.coinAmount.isZero) return
+const getPolygonStakingTxData = ({ tx, currency }) => {
+  if (['delegate', 'undelegate', 'claimUndelegate'].some((stakeTx) => tx.data?.[stakeTx])) return
+
+  const txAmount = tx.coinAmount.toDefaultString()
 
   if (isPolygonDelegate(tx)) {
-    const stakeTxAmount = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
-    return { delegate: stakeTxAmount }
+    const delegate = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
+    // MATIC returned in unstake tx is always reward
+    const rewards = calculateRewardsFromStakeTx({ tx, currency })
+    return { delegate, txAmount, ...(rewards ? { rewards } : {}) }
   }
 
-  if (isPolygonClaimUndelegate(tx)) return { undelegate: tx.coinAmount.toDefaultString() }
+  if (isPolygonUndelegate(tx)) {
+    const undelegate = currency.baseUnit(decodePolygonStakingTxInputAmount(tx)).toDefaultString()
+    // MATIC returned in unstake tx is always reward
+    const rewards = txAmount
+    return { undelegate, txAmount, rewards }
+  }
+
+  if (isPolygonClaimUndelegate(tx)) {
+    return { claimUndelegate: txAmount, txAmount }
+  }
 }
 
 export const assetStakingTxData = {
-  polygon: getPolygonStakeTxType,
-  ethereum: getEthereumStakeTxType,
-  ethereumholesky: getEthereumStakeTxType,
+  polygon: getPolygonStakingTxData,
+  ethereum: getEthereumStakingTxData,
+  ethereumholesky: getEthereumStakingTxData,
 }

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

@@ -1,7 +1,6 @@
 import { assetStakingTxData } from './asset-staking-tx-data'
-import { getStakeTxAmount } from './get-asset-tx-amount'
 
-const getTxStakeData = ({ assetName, currency, tx }) => {
+const getTxStakingData = ({ assetName, currency, tx }) => {
   return assetStakingTxData[assetName]({ tx, currency })
 }
 
@@ -11,13 +10,12 @@ const processTxLog = async ({ asset, assetClientInterface: aci, walletAccount, b
 
   const newTxs = []
   for (const tx of txs) {
-    const txStakeData = getTxStakeData({ assetName, currency, tx })
-    if (txStakeData) {
-      const txAmount = getStakeTxAmount[assetName]({ tx, currency, type: txStakeData })
+    const stakingData = getTxStakingData({ assetName, currency, tx })
+    if (stakingData) {
       newTxs.push({
         ...tx,
-        coinAmount: txAmount,
-        data: { ...tx.data, ...txStakeData },
+        coinAmount: currency.ZERO,
+        data: { ...tx.data, ...stakingData },
       })
     }
   }

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

@@ -18,7 +18,7 @@ export const decodePolygonStakingTxInputAmount = (tx) => {
   return amount
 }
 
-export const calculateTxAmountAndRewardFromStakeTx = ({ tx, currency }) => {
+export const calculateRewardsFromStakeTx = ({ tx, currency }) => {
   const stakedAmount = currency.baseUnit(decodePolygonStakingTxInputAmount(tx))
   const { reward } = tx.data
   // stake tx might have rewards in it,
@@ -35,12 +35,8 @@ export const calculateTxAmountAndRewardFromStakeTx = ({ tx, currency }) => {
   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
+    return txAmount.toBaseString()
   }
-
-  // no rewards, set stake tx amount to ZERO
-  return currency.ZERO
 }
 
 export const decodeEthLikeStakingTxInputAmount = (tx) => {

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

@@ -1,26 +0,0 @@
-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,
-}