@exodus/ethereum-api 9.0.0-alpha.2 → 9.0.0

package/src/gas-estimation.js

@@ -1,113 +1,230 @@
-import BN from 'bn.js'
-import * as ethUtil from '@exodus/ethereumjs-util'
-import { currency2buffer, isToken } from '@exodus/ethereum-lib'
-import { estimateGas, isContractAddressCached } from './eth-like-util'
+import { currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
+import { bufferToHex, toBuffer } from '@exodus/ethereumjs/util'
 
-const EXTRA_PERCENTAGE = 20
+import { estimateGas, isContractAddressCached, isForwarderContractCached } from './eth-like-util.js'
+import {
+  ARBITRARY_ADDRESS,
+  resolveCriticalTxAttributes,
+  TX_TYPE_TRANSFER,
+} from './tx-type/index.js'
+
+export const DEFAULT_GAS_LIMIT_MULTIPLIER = 1.29
 
 // 16 gas per non-zero byte (4 gas per zero byte) of "transaction input data"
 const GAS_PER_NON_ZERO_BYTE = 16
 
 export const DEFAULT_CONTRACT_GAS_LIMIT = 1e6
+export const DEFAULT_TOKEN_GAS_LIMIT = 120e3
+export const DEFAULT_GAS_LIMIT = 21_000
+
+// HACK: RPCs generally provide imprecise estimates
+//       for `gasUsed` (often these are insufficient).
+export const scaleGasLimitEstimate = ({
+  estimatedGasLimit,
+  gasLimitMultiplier = DEFAULT_GAS_LIMIT_MULTIPLIER,
+}) => {
+  const gasLimit = parseInt(estimatedGasLimit)
+  if (!Number.isInteger(gasLimit)) {
+    throw new TypeError('Invalid scaleGasLimitEstimate ' + estimatedGasLimit)
+  }
+
+  const multiplier = parseFloat(gasLimitMultiplier)
+  if (Number.isNaN(multiplier)) {
+    throw new TypeError('Invalid gasLimitMultiplier ' + gasLimitMultiplier)
+  }
+
+  return Math.floor(gasLimit * multiplier)
+}
 
 // Starting with geth v1.9.14, if gasPrice is set for eth_estimateGas call, the call allowance will
 // be calculated with account's balance divided by gasPrice. If user's balance is too low,
 // the gasEstimation will fail. If gasPrice is set to '0x0', the account's balance is not
 // used to estimate gas.
-export async function estimateGasLimit(
+export async function estimateGasLimit({
   asset,
   fromAddress,
   toAddress,
-  amount,
+  // TODO: rename to value, as this is `msg.value`.
+  amount = asset.currency.ZERO,
   data,
   gasPrice = '0x',
-  extraPercentage = EXTRA_PERCENTAGE
-) {
+}) {
   const opts = {
     from: fromAddress,
     to: toAddress,
     value: normalizeAmount(amount),
-    data: Buffer.isBuffer(data) ? ethUtil.bufferToHex(data) : data,
+    data: Buffer.isBuffer(data) ? bufferToHex(data) : data,
     gasPrice: normalizeGasPrice(gasPrice),
   }
 
   const estimatedGas = await estimateGas({ asset, ...opts })
-  return new BN(estimatedGas.slice(2), 16)
-    .imuln(100 + extraPercentage)
-    .idivn(100)
-    .toNumber()
+  return Number(BigInt(estimatedGas))
 }
 
-export async function fetchGasLimit({
-  asset,
-  fromAddress,
-  toAddress,
-  txInput = '0x',
-  amount,
-  bip70,
-  throwOnError = true,
-  extraPercentage,
-}) {
-  if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice)
-    return asset.name === 'ethereum' ? 65_000 : 130_000 // from on chain stats https://dune.xyz/queries/189123
+export async function resolveGasLimitMultiplier({ asset, feeData, toAddress, fromAddress }) {
+  const gasLimitMultiplierWhenUnknownAddress =
+    feeData?.gasLimits?.[asset.name]?.gasLimitMultiplierWhenUnknownAddress
 
-  if (!amount) amount = asset.currency.ZERO
+  // NOTE: If either the `fromAddress` or `toAddress` has fell
+  //       back to the `ARBITRARY_ADDRESS`, these qualify as
+  //       "unknown" addresses.
+  const fromAddressIsUnknown = fromAddress === ARBITRARY_ADDRESS
+  const toAddressIsUnknown = toAddress === ARBITRARY_ADDRESS
 
-  const defaultGasLimit = () =>
-    asset.gasLimit + GAS_PER_NON_ZERO_BYTE * ethUtil.toBuffer(txInput).length
+  if (gasLimitMultiplierWhenUnknownAddress && (fromAddressIsUnknown || toAddressIsUnknown)) {
+    return gasLimitMultiplierWhenUnknownAddress
+  }
 
-  const _isToken = isToken(asset)
+  const gasLimitMultiplier = feeData?.gasLimits?.[asset.name]?.gasLimitMultiplier
 
-  const isContract = await isContractAddressCached({ asset, address: toAddress })
+  if (gasLimitMultiplier) {
+    return gasLimitMultiplier
+  }
 
-  if (_isToken) {
-    // only create tx-input only if not pass tx-input to a token asset
-    if (txInput === '0x') {
-      txInput = ethUtil.bufferToHex(
-        asset.contract.transfer.build(toAddress.toLowerCase(), amount.toBaseString())
-      )
-    }
+  if (asset.baseAsset.estimateL1DataFee) {
+    return 2
+  }
+
+  const isToken = asset.name !== asset.baseAsset.name
+
+  // calling forwarder contracts with a bumped gas limit causes 'Out Of Gas' error on chain
+  const hasForwarderContract =
+    !isToken && toAddress ? await isForwarderContractCached({ asset, address: toAddress }) : false
+
+  if (hasForwarderContract) {
+    return 1
+  }
 
-    amount = asset.baseAsset.currency.ZERO
-    toAddress = asset.contract.address
-  } else if (
-    !isContract &&
-    // hacky, convert this to a fetchGasLimit forceGasLimitEstimation plugin flag!
-    ![
-      'ethereumarbone',
-      'ethereumarbonesepolia',
-      'ethereumarbnova',
-      'mantle',
-      'mantlesepolia',
-    ].includes(asset.name)
+  return DEFAULT_GAS_LIMIT_MULTIPLIER
+}
+
+// https://eips.ethereum.org/EIPS/eip-7623
+export const getEip7623CalldataCost = (calldata) => {
+  calldata = toBuffer(calldata)
+
+  const TOTAL_COST_FLOOR_PER_TOKEN = 10
+
+  const nonZeroBytesInCalldata = calldata.filter(Boolean).length
+  const zeroBytesInCalldata = calldata.length - nonZeroBytesInCalldata
+  const tokensInCalldata = zeroBytesInCalldata + nonZeroBytesInCalldata * 4
+
+  return TOTAL_COST_FLOOR_PER_TOKEN * tokensInCalldata
+}
+
+export const defaultGasLimit = ({ asset, txInput }) => {
+  const isToken = isEthereumLikeToken(asset)
+
+  const calldataCost = asset.baseAsset.eip7623Supported
+    ? getEip7623CalldataCost(txInput)
+    : GAS_PER_NON_ZERO_BYTE * toBuffer(txInput).length
+
+  return (isToken ? DEFAULT_TOKEN_GAS_LIMIT : DEFAULT_GAS_LIMIT) + calldataCost
+}
+
+// TODO: `gasLimit` needs to be a responsibility of `resolveTxAttributesByTxType`.
+export async function fetchGasLimit({
+  asset,
+  feeData,
+  fromAddress: providedFromAddress,
+  toAddress: providedToAddress,
+  txInput: providedTxInput,
+  txValue: providedTxValue,
+  amount: providedAmount,
+  contractAddress: providedTxToAddress,
+  bip70,
+  txType = TX_TYPE_TRANSFER,
+  throwOnError = true,
+  isSendAll = false,
+}) {
+  if (bip70?.bitpay?.data && bip70?.bitpay?.gasPrice) {
+    // from on chain stats https://dune.xyz/queries/189123
+    return asset.name === 'ethereum' ? 65_000 : 130_000
+  }
+
+  // TODO: If we can provide the `walletAccount` via `fetchGasLimit` then
+  //       we can use `resolveTxAttributesByTxType` instead (and remove
+  //       the concept of critical attributes).
+  const { txToAddress, txInput, txValue } = resolveCriticalTxAttributes({
+    asset,
+    amount: providedAmount,
+    toAddress: providedToAddress,
+    txToAddress: providedTxToAddress,
+    txInput: providedTxInput,
+    txValue: providedTxValue,
+    txType,
+  })
+
+  const isContractTxToAddress =
+    Boolean(txToAddress) && (await isContractAddressCached({ asset, address: txToAddress }))
+
+  const fromAddress = providedFromAddress ?? ARBITRARY_ADDRESS
+
+  const isToken = isEthereumLikeToken(asset)
+
+  if (
+    txType === TX_TYPE_TRANSFER &&
+    !isToken &&
+    !isContractTxToAddress &&
+    !asset.forceGasLimitEstimation
   ) {
-    return defaultGasLimit()
+    return defaultGasLimit({ asset, txInput })
   }
 
-  // calling forwarder contracts with a bumped gas limit causes 'Out Of Gas' error on chain
-  // Since geth v1.9.14 estimateGas will throw if user does not have enough ETH.
-  // If gasPrice is set to zero, estimateGas will make the expected estimation.
-  const gasPrice = ethUtil.bufferToHex(currency2buffer(asset.baseAsset.currency.ZERO))
+  const gasLimitMultiplier = await resolveGasLimitMultiplier({
+    asset,
+    feeData,
+    fromAddress,
+    toAddress: txToAddress,
+  })
 
   try {
-    return await estimateGasLimit(
+    // NOTE: Although we'll return the `fixedGasLimit` for known
+    //       tokens, we'll still want to execute `estimateGasLimit`
+    //       to verify their transaction actually succeeds (i.e.
+    //       they aren't trying to transfer more than their balance).
+    //
+    //       This prevents users from submitting `fixedGasLimit`
+    //       token transactions which result in a `revert`.
+    const estimatedGasLimit = await estimateGasLimit({
       asset,
       fromAddress,
-      toAddress,
-      amount,
-      txInput,
-      gasPrice,
-      extraPercentage
-    )
+      toAddress: txToAddress,
+      amount: txValue,
+      data: txInput,
+    })
+
+    const scaledGasLimitEstimate = scaleGasLimitEstimate({ estimatedGasLimit, gasLimitMultiplier })
+    if (!isToken) {
+      // For native send-all on EOA targets, return the raw `eth_estimateGas`
+      // result (no 2x safety pad). Combined with the EIP-1559 tip override
+      // applied in tx-create.js (also gated on `isSendAll && !isContract`),
+      // this is the no-dust path: gasLimit ≈ gasUsed, so nothing comes back
+      // as refund. For contracts we keep the safety pad because contract
+      // gas can be nondeterministic against estimates.
+      return isSendAll && !isContractTxToAddress ? estimatedGasLimit : scaledGasLimitEstimate
+    }
+
+    // NOTE: If we've enabled `fixGasLimit`s for a token,
+    //       we need to make sure that transaction we're
+    //       making actually targets that token.
+    //
+    //       Otherwise, we risk applying the fixed gas limit
+    //       to transactions with _other_ smart contracts
+    //       simply because the caller specified the token
+    //       asset.
+    const isTokenTransaction = asset.contract.address.toLowerCase() === txToAddress.toLowerCase()
+    if (!isTokenTransaction) return scaledGasLimitEstimate
+
+    return feeData?.gasLimits?.[asset.name]?.fixedGasLimit ?? scaledGasLimitEstimate
   } catch (err) {
     if (throwOnError) throw err
+
     console.error('fetchGasLimit error', err)
 
     // fallback value for contract case
-    if (isContract) return asset.contractGasLimit || DEFAULT_CONTRACT_GAS_LIMIT
+    if (isContractTxToAddress) return DEFAULT_CONTRACT_GAS_LIMIT
 
-    // fallback value for rest cases: token.
-    return defaultGasLimit()
+    return defaultGasLimit({ asset, txInput })
   }
 }
 
@@ -116,7 +233,7 @@ function normalizeAmount(amount) {
     amount = currency2buffer(amount)
   }
 
-  amount = ethUtil.bufferToHex(amount)
+  amount = bufferToHex(amount)
   while (amount[2] === '0') amount = '0x' + amount.slice(3)
   if (amount === '0x') amount = '0x0'
 

package/src/get-balance-for-address.js

@@ -4,7 +4,7 @@ export const createGetBalanceForAddress = ({ asset, server }) => {
   assert(asset, 'asset is required')
   assert(server, 'server is required')
   return async (address) => {
-    const balance = await server.getBalance(address)
+    const balance = await server.getBalanceProxied(address)
     if (typeof balance === 'string') {
       // hex-response from eth_getBalance node
       return asset.currency.baseUnit(balance)

package/src/get-balances.js

@@ -1,29 +1,241 @@
-import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
-
-import { get } from 'lodash'
-import assert from 'minimalistic-assert'
-
 import {
   getBalanceFromAccountState,
+  getBalanceFromAccountStateIfAny,
   getBalanceFromTxLog,
   getUnconfirmedReceivedBalance,
   getUnconfirmedSentBalance,
 } from '@exodus/asset-lib'
+import assert from 'minimalistic-assert'
 
-const getStaked = ({ accountState, asset }) => {
-  return get(accountState, ['staking', asset.name, 'delegatedBalance']) || asset.currency.ZERO
+import { getLatestCanonicalAbsoluteBalanceTx } from './tx-log/clarity-utils/index.js'
+
+/**
+ * Native balance helper for {@link getAbsoluteBalance}. Only consults
+ * `accountState` when the txLog is empty; otherwise the caller walks the
+ * txLog for a `balanceChange`. Inside the empty-txLog branch, picks a
+ * signal in decreasing order of trust:
+ *
+ *   1. Non-zero `accountState.balance` (authoritative — RPC `eth_getBalance`
+ *      result or `accountInfo` `account_balance` row from truncated history).
+ *   2. `truncatedAccountState.balance` (state at the cursor), default ZERO.
+ *
+ * ZERO is treated as "no signal" because `EthereumLikeAccountState` defaults
+ * `balance` to ZERO; we cannot distinguish "model default" from "chain says
+ * you hold 0". The truncated baseline acts as the explicit fallback.
+ */
+const getBaseBalanceFromAccountState = ({ asset, txLog, accountState }) => {
+  if (txLog.size === 0) {
+    const balance = getBalanceFromAccountStateIfAny({ asset, accountState })
+    if (balance && !balance.isZero) return balance
+
+    return getTruncatedBaseBalance({ accountState }) ?? asset.currency.ZERO
+  }
+
+  return null
+}
+
+/**
+ * Token counterpart of {@link getBaseBalance}. Tokens are sparse — there's no
+ * model default for `tokenBalances[name]`, so any value present (including an
+ * explicit ZERO from `accountInfo` after the user drained the token) is
+ * authoritative and returned as-is. Only when the key is missing entirely do
+ * we fall through to the truncated baseline / txLog walk.
+ */
+const getTokenBalanceFromAccountState = ({ asset, txLog, accountState }) => {
+  const balance = getBalanceFromAccountStateIfAny({ asset, accountState })
+  if (balance) return balance
+
+  if (txLog.size === 0) {
+    return getTruncatedTokenBalance({ asset, accountState }) ?? asset.currency.ZERO
+  }
+
+  return null
+}
+
+/**
+ * Cursor-baseline native balance from {@link accountState.truncatedAccountState},
+ * sourced from Clarity `truncated` `accountInfo` rows on initial `cursor=0`
+ * fetch. Returns `undefined` when the snapshot isn't populated (e.g. the
+ * server didn't ship a baseline for this account).
+ */
+const getTruncatedBaseBalance = ({ accountState }) => accountState?.truncatedAccountState?.balance
+
+/**
+ * Token counterpart of {@link getTruncatedBaseBalance}.
+ */
+const getTruncatedTokenBalance = ({ asset, accountState }) =>
+  accountState?.truncatedAccountState?.tokenBalances?.[asset.name]
+
+/**
+ * TODO: Balance model gaps for EVM staking assets
+ *
+ * Missing fields that should be added to getBalancesFactory return value:
+ *
+ * 1. `rewards` / `liquidRewards` - Currently, accountState.staking[asset.name] contains
+ *    rewardsBalance and liquidRewards (from asset.api.staking.getStakingInfo → accountState.staking),
+ *    but getBalancesFactory doesn't read or expose them. Need a getRewards() helper similar
+ *    to getStaked() and getStaking().
+ *
+ * 2. `rewardsBalance` (total lifetime rewards) - Available in accountState but not surfaced.
+ *
+ * 3. `withdrawable` - For Polygon, this represents claimable rewards, distinct from
+ *    unclaimedUndelegatedBalance (unstaked principal). Currently conflated.
+ *
+ * 4. `walletReserve` - Documented in balances-model.md but not implemented.
+ *
+ * 5. `staking` field reads pendingBalance + pendingDepositedBalance, which Polygon staking
+ *    doesn't return (only Ethereum native staking uses these). Needs asset-specific handling.
+ *
+ * The data flow already exists: monitor hooks call getStakingInfo() → accountState.staking[asset.name].
+ * Implementation would add helper functions (getLiquidRewards, getRewardsBalance, etc.) and
+ * include these in the returned balance object, standardized across Ethereum/Polygon/etc.
+ *
+ * See: docs/balances-model.md for the intended balance model spec.
+ */
+export const getAbsoluteBalance = ({ asset, txLog, accountState }) => {
+  assert(asset, 'asset is required')
+  assert(txLog, 'txLog is required')
+
+  const isBase = asset.name === asset.baseAsset.name
+  const accountStateBalance = isBase
+    ? getBaseBalanceFromAccountState({ asset, txLog, accountState })
+    : getTokenBalanceFromAccountState({ asset, txLog, accountState })
+  if (accountStateBalance) {
+    // Authoritative `accountState` snapshot (or empty-txLog terminal value).
+    return accountStateBalance
+  }
+
+  // NOTE: We reverse the `txLog` to prioritize the handling
+  //       of the most recent transactions first. The reason
+  //       we do this is to terminate early if we find an
+  //       absolute balance node.
+  const reversedTxLog = txLog.reverse()
+
+  const maybeLatestAbsoluteBalanceTx = getLatestCanonicalAbsoluteBalanceTx({ reversedTxLog })
+
+  let balance = asset.currency.ZERO
+  let hasAbsoluteBalance = false
+
+  for (const tx of reversedTxLog) {
+    if (tx.data.balanceChange) {
+      // If we are aware of the existence of the most
+      // recent absolute balance, then we can ignore
+      // any competing instances.
+      if (maybeLatestAbsoluteBalanceTx && tx.txId !== maybeLatestAbsoluteBalanceTx.txId) {
+        continue
+      }
+
+      hasAbsoluteBalance = true
+      balance = balance.add(asset.currency.baseUnit(tx.data.balanceChange.to))
+
+      break
+    }
+
+    // NOTE: Avoids processing any unconfirmed balances, since
+    //       `getAbsoluteBalance` only processes a subset of
+    //       transactions up until the first `balanceChange` event
+    //       is encountered, but `getBalancesFactory` takes all
+    //       all pending amounts into consideration (i.e. those
+    //       at a greater depth than the most recent `balanceChange`
+    //       event).
+    if (!tx.failed && tx.pending) continue
+
+    if (!(tx.dropped || tx.data.replacedBy)) {
+      if (!tx.error) {
+        balance = balance.add(tx.coinAmount)
+      }
+
+      if (tx.feeAmount?.unitType.equals(tx.coinAmount.unitType)) {
+        balance = balance.sub(tx.feeAmount)
+      }
+    }
+  }
+
+  if (!hasAbsoluteBalance) {
+    // Last line of defense: under truncated history the post-cursor txLog can
+    // omit the most recent `balanceChange` (e.g. only a pending send remains).
+    // Anchor on the `accountInfo` snapshot, mirroring the same precedence as
+    // {@link getBaseBalanceFromAccountState} / {@link getTokenBalanceFromAccountState}:
+    // prefer the current `accountState.balance` (`account_balance` row), and
+    // fall back to `truncatedAccountState.balance` (cursor baseline) when the
+    // former is the model default ZERO.
+    const accountBalance = isBase
+      ? accountState?.balance
+      : accountState?.tokenBalances?.[asset.name]
+    if (accountBalance && (!isBase || !accountBalance.isZero)) {
+      return balance.add(accountBalance)
+    }
+
+    const truncatedBalance = isBase
+      ? getTruncatedBaseBalance({ accountState })
+      : getTruncatedTokenBalance({ asset, accountState })
+    if (truncatedBalance) return balance.add(truncatedBalance)
+
+    console.warn('No absolute balance found', { assetName: asset.name, txLogSize: txLog.size })
+    return
+  }
+
+  return balance
 }
 
-const getUnstaking = ({ accountState, asset }) => {
-  return get(accountState, ['staking', asset.name, 'undelegatedBalance']) || asset.currency.ZERO
+const getStaked = ({ accountState, asset }) => {
+  return accountState?.staking?.[asset.name]?.activeStakedBalance || asset.currency.ZERO
 }
 
-const getUnstaked = ({ accountState, asset }) => {
-  return (
-    get(accountState, ['staking', asset.name, 'unclaimedUndelegatedBalance']) || asset.currency.ZERO
+const getStaking = ({ accountState, asset }) => {
+  return (accountState?.staking?.[asset.name]?.pendingBalance || asset.currency.ZERO).add(
+    accountState?.staking?.[asset.name]?.pendingDepositedBalance || asset.currency.ZERO
   )
 }
 
+const getUnclaimedUndelegatedBalance = ({ accountState, asset }) => {
+  return accountState?.staking?.[asset.name]?.unclaimedUndelegatedBalance || asset.currency.ZERO
+}
+
+const getCanClaimUndelegatedBalance = ({ accountState, asset }) =>
+  accountState?.staking?.[asset.name]?.canClaimUndelegatedBalance || false
+
+/**
+ * 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
+    const txData = tx.data
+
+    // staking tx must has data value
+    if (!txData) continue
+
+    let { txAmount } = txData
+    if (successfulTx && (txAmount || txData.delegate)) {
+      // only staking txs have tx.data.txAmount set
+
+      if (txData.delegate && !txAmount) {
+        txAmount = txData.delegate // fix missing txAmount in stakeTx
+      }
+
+      stakingHistoryBalance = stakingHistoryBalance.add(asset.currency.defaultUnit(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.
  *
@@ -32,33 +244,79 @@ const getUnstaked = ({ accountState, asset }) => {
  * @param accountState the account state when the balance is loaded from RPC
  * @returns {{balance}|null} an object with the balance or null if the balance is unknown
  */
-export const getBalancesFactory = ({ monitorType }) => {
+export const getBalancesFactory = ({ monitorType, useAbsoluteBalance, rpcBalanceAssetNames }) => {
   assert(monitorType, 'monitorType is required')
   return ({ asset, txLog, accountState }) => {
     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)
+    const staking = getStaking({ asset, accountState })
+
+    const canClaimUndelegatedBalance = getCanClaimUndelegatedBalance({ accountState, asset })
+
+    const unclaimedUndelegatedBalance = getUnclaimedUndelegatedBalance({ asset, accountState })
+
+    const unstaking = canClaimUndelegatedBalance ? asset.currency.ZERO : unclaimedUndelegatedBalance
+    const unstaked = canClaimUndelegatedBalance ? unclaimedUndelegatedBalance : asset.currency.ZERO
+
+    let spendable
+
+    // Balance from accountState is considered total b/c is fetched from rpc
+    if (rpcBalanceAssetNames.includes(asset.name) || monitorType === 'no-history') {
+      // NOTE: Balances from a `no-history` monitor work like calls
+      //       to `balanceOf`/`eth_getBalance` at the latest block tag,
+      //       therefore there's no need to subtract `unconfirmedReceived`.
+      //
+      //       Likewise, they do not compensate for pending sends, so we
+      //       must manually subtract the `unconfirmedSent` to produce a
+      //       pessimistic reading that's safe for consumers.
+      spendable = getBalanceFromAccountState({ asset, accountState }).sub(unconfirmedSent)
+    } else {
+      const absoluteBalance =
+        useAbsoluteBalance && getAbsoluteBalance({ asset, txLog, accountState })
+
+      if (absoluteBalance) {
+        // NOTE: The returned `absoluteBalance` returns only confirmed
+        //       values similar to the `'no-history'` case, so we need
+        //       to reduce this amount by the `unconfirmedSent`.
+        spendable = absoluteBalance.sub(unconfirmedSent)
+      } 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,
+        })
+      }
+    }
+
+    // A pending send already reflected in the account-state reading is double-counted
+    // via `unconfirmedSent`, making spendable transiently negative (bounded by
+    // `unconfirmedSent`). A negative beyond that bound is a real accounting bug.
+    if (spendable.isNegative && spendable.abs().gt(unconfirmedSent)) {
+      console.warn('unexpected negative spendable beyond pending sends', {
+        assetName: asset.name,
+        spendable: spendable.toBaseString(),
+        unconfirmedSent: unconfirmedSent.toBaseString(),
+      })
+    }
+
+    // Clamp before deriving `total` so the artifact doesn't drag it below staked balances.
+    spendable = spendable.clampLowerZero()
+
+    const total = spendable.add(staked).add(staking).add(unstaking).add(unstaked)
+    const stakeable = spendable
 
     return {
       // new
       spendable,
       total,
+      stakeable,
       staked,
+      staking,
       unstaking,
       unstaked,
       unconfirmedReceived,