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

package/src/get-fee.js

@@ -1,25 +1,28 @@
-import { calculateBumpedGasPrice, calculateExtraEth, isEthereumLike } from '@exodus/ethereum-lib'
+import {
+  calculateBumpedGasPrice,
+  calculateBumpedGasPriceForFeeData,
+  calculateExtraEth,
+  isEthereumLikeToken,
+} from '@exodus/ethereum-lib'
+import assert from 'minimalistic-assert'
+
+import {
+  ensureSaneEip1559GasPriceForTipGasPrice,
+  getNormalizedFeeDataForCustomFee,
+  resolveGasPrice,
+} from './fee-utils.js'
+import { defaultGasLimit } from './gas-estimation.js'
 
 // Move to meta?
 const taxes = {
   paxgold: 0.0002,
 }
 
-const getGasPriceMultiplier = ({ asset, feeData, isExchange, isSendAll, isRbfAllowed }) => {
-  // exchanges quotes expire, do not risk having a stuck tx
-  if (isExchange) return 1
-
-  // if eip1559 enabled, do not risk not leaving enough ETH to cover base fee (applies only for native asset)
-  // (gasPrice difference will be reimbursed anyway: users do not overpay)
-  if (isSendAll && isEthereumLike(asset) && feeData.eip1559Enabled) return 1
-
-  // do not risk having a stuck tx if we're not able to accelerate it
-  if (!isRbfAllowed || !feeData.rbfEnabled) return 1
-
-  return feeData.gasPriceEconomicalRate
-}
+export const getExtraFeeData = ({ asset, amount, txValue }) => {
+  if (isEthereumLikeToken(asset) && txValue?.gt(asset.baseAsset.currency.ZERO)) {
+    return { type: 'tax', extraFee: txValue }
+  }
 
-const getExtraFeeData = ({ asset, amount }) => {
   const tax = taxes[asset.name]
   if (!amount || !tax || amount.isZero) {
     return {}
@@ -33,62 +36,95 @@ const getExtraFeeData = ({ asset, amount }) => {
   }
 }
 
-export const getFeeFactory =
-  ({ gasLimit: defaultGasLimit }) =>
-  ({
-    asset,
+const getGasPricesResult = ({ gasPrice, feeData }) => {
+  const { tipGasPrice, eip1559Enabled } = feeData
+  return {
+    gasPrice: eip1559Enabled
+      ? // NOTE: The `gasPrice` must be at least the `tipGasPrice`.
+        ensureSaneEip1559GasPriceForTipGasPrice({ gasPrice, tipGasPrice })
+      : gasPrice,
     feeData,
-    customFee,
-    gasLimit = defaultGasLimit,
-    isExchange,
-    isSendAll,
-    amount,
-    isRbfAllowed = true, // Destkop, isRbfAllowed=true when advanced panel is on
-    calculateEffectiveFee,
-  }) => {
-    const { gasPrice, eip1559Enabled, baseFeePerGas, tipGasPrice } = feeData
-    const gasPriceMultiplier = getGasPriceMultiplier({
-      asset,
-      isRbfAllowed,
-      feeData,
-      isExchange,
-      isSendAll,
-    })
+  }
+}
 
-    const extraFeeData = getExtraFeeData({ asset, amount })
-    if (calculateEffectiveFee && eip1559Enabled) {
-      const maxFeePerGas = customFee || gasPrice
-      // effective_gas_price = min(base_fee_per_gas + tip_gas_price, max_fee_per_gas)
-      const feePerGas = baseFeePerGas.add(tipGasPrice)
-      const effectiveGasPrice = feePerGas.lt(maxFeePerGas) ? feePerGas : maxFeePerGas
+const getGasPricesForTxToReplace = ({ baseAsset, feeData, txToReplace }) => {
+  const { eip1559Enabled } = feeData
 
-      return { fee: effectiveGasPrice.mul(gasLimit), extraFeeData }
-    }
+  const effectiveGasPrice = resolveGasPrice({ feeData })
+  const { tipGasPrice: effectiveTipGasPrice } = feeData
 
-    const fee = (customFee || gasPrice.mul(gasPriceMultiplier)).mul(gasLimit || asset.gasLimit)
-    return { fee, extraFeeData }
-  }
+  const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPriceForFeeData({
+    baseAsset,
+    feeData,
+    tx: txToReplace,
+  })
+
+  const gasPrice = bumpedGasPrice.gt(effectiveGasPrice) ? bumpedGasPrice : effectiveGasPrice
+  if (!eip1559Enabled) return getGasPricesResult({ gasPrice, feeData })
+
+  const tipGasPrice = bumpedTipGasPrice.gt(effectiveTipGasPrice)
+    ? bumpedTipGasPrice
+    : effectiveTipGasPrice
 
-// Used in BE
-export const getEffectiveGasPrice = ({ feeData }) => {
-  const { baseFeePerGas, tipGasPrice, gasPrice: maxFeePerGas, eip1559Enabled } = feeData
+  return getGasPricesResult({
+    gasPrice,
+    feeData: { ...feeData, tipGasPrice },
+  })
+}
+
+export const getAggregateTransactionPricing = ({ baseAsset, customFee, feeData, txToReplace }) => {
+  assert(baseAsset, 'expected baseAsset')
 
-  if (!eip1559Enabled) {
-    return maxFeePerGas
+  if (customFee) {
+    return getGasPricesResult({
+      gasPrice: customFee,
+      feeData: getNormalizedFeeDataForCustomFee({ customFee, feeData }),
+    })
   }
 
-  const gasPrice = baseFeePerGas.add(tipGasPrice)
-  return gasPrice.lt(maxFeePerGas) ? gasPrice : maxFeePerGas
+  if (txToReplace) return getGasPricesForTxToReplace({ baseAsset, feeData, txToReplace })
+
+  return getGasPricesResult({
+    gasPrice: resolveGasPrice({ feeData }),
+    feeData,
+  })
 }
 
+export const getFeeFactory =
+  () =>
+  ({ asset, feeData, customFee, txInput, gasLimit: providedGasLimit, amount, txValue }) => {
+    const {
+      feeData: { tipGasPrice, eip1559Enabled },
+      gasPrice,
+    } = getAggregateTransactionPricing({
+      baseAsset: asset.baseAsset,
+      customFee,
+      feeData,
+    })
+
+    const gasLimit = providedGasLimit ?? defaultGasLimit({ asset, txInput })
+
+    // When explicitly opting into EIP-1559 transactions,
+    // lock in the `tipGasPrice` we used to compute the fees.
+    const maybeReturnTipGasPrice = eip1559Enabled ? { tipGasPrice } : null
+
+    const extraFeeData = getExtraFeeData({ asset, amount, txValue })
+
+    const fee = gasPrice.mul(gasLimit)
+    return { ...maybeReturnTipGasPrice, fee, gasPrice, extraFeeData }
+  }
+
 // Used in Mobile
-export const getExtraFeeForBump = ({ tx, feeData, balance, unconfirmedBalance }) => {
+export const getExtraFeeForBump = ({ baseAsset, tx, feeData, balance, unconfirmedBalance }) => {
+  assert(baseAsset, 'expected baseAsset')
+
   if (!balance || !unconfirmedBalance) return null
-  const { gasPrice: currentGasPrice, eip1559Enabled } = feeData
+  const { gasPrice: currentGasPrice, eip1559Enabled, baseFeePerGas: currentBaseFee } = feeData
   const { bumpedGasPrice } = calculateBumpedGasPrice({
-    baseAsset: 'ethereum',
+    baseAsset,
     tx,
     currentGasPrice,
+    currentBaseFee,
     eip1559Enabled,
   })
   return calculateExtraEth({

package/src/get-historical-balance.js

@@ -0,0 +1,58 @@
+import { TxSet } from '@exodus/models'
+import assert from 'minimalistic-assert'
+
+import { getLatestCanonicalAbsoluteBalanceTx } from './tx-log/clarity-utils/index.js'
+
+const walkBackFromBalance = ({ txLog, deadline, balance }) => {
+  let result = balance
+
+  for (const tx of txLog) {
+    if (new Date(tx.date).getTime() <= deadline) continue
+    if (tx.failed || tx.dropped || tx.pending || tx.data?.replacedBy) continue
+
+    result = result.sub(tx.coinAmount)
+    if (tx.feeAmount?.unitType.equals(tx.coinAmount.unitType)) {
+      result = result.add(tx.feeAmount)
+    }
+  }
+
+  return result.clampLowerZero()
+}
+
+/**
+ * Builds the Ethereum-like balance as of `date`. Anchors on the latest Clarity
+ * absolute-balance snapshot at or before the date, falling back to a walk-back
+ * from the current balance when no snapshot is available.
+ */
+export const getHistoricalBalanceFactory = ({ assetClientInterface, getBalances }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(getBalances, 'getBalances is required')
+
+  return async ({ asset, walletAccount, date }) => {
+    assert(asset, 'asset is required')
+    assert(walletAccount, 'walletAccount is required')
+    assert(date instanceof Date, 'date is required')
+
+    const txLog = await assetClientInterface.getTxLog({ assetName: asset.name, walletAccount })
+    const deadline = date.getTime()
+    const anchor = getLatestCanonicalAbsoluteBalanceTx({ reversedTxLog: txLog.reverse(), deadline })
+
+    if (anchor) {
+      const total = asset.currency.baseUnit(anchor.data.balanceChange.to)
+      return { total, entries: [{ amount: total, date: deadline }] }
+    }
+
+    const accountState = await assetClientInterface.getAccountState({
+      assetName: asset.baseAsset.name,
+      walletAccount,
+    })
+    const confirmedTxLog = TxSet.fromArray([...txLog].filter((tx) => !tx.pending))
+    const balance = getBalances({ asset, accountState, txLog: confirmedTxLog }).spendable
+    const total = walkBackFromBalance({ txLog: confirmedTxLog, deadline, balance })
+
+    return {
+      total,
+      entries: [{ amount: total, date: deadline }],
+    }
+  }
+}

package/src/hooks/index.js

@@ -1 +1 @@
-export { createEthereumHooks } from './monitor'
+export { createEthereumHooks } from './monitor.js'

package/src/hooks/monitor.js

@@ -1,72 +1,211 @@
-import { getEthereumStakingInfo, getPolygonStakingInfo } from '../staking'
-import processTxLog from '../tx-log-staking-processor'
 import assert from 'minimalistic-assert'
 
+import processTxLog from '../tx-log-staking-processor/index.js'
+import { getStakingActivity, stakingStateInterval } from './staking-freshness.js'
+
+// Service-owned fields must never leak between delegator snapshots. Keep host
+// annotations outside this set; new service fields must be added here as well.
+const STAKING_SNAPSHOT_FIELDS = new Set([
+  'rewardsBalance',
+  'isDelegating',
+  'activeStakedBalance',
+  'delegatedBalance',
+  'pendingBalance',
+  'pendingDepositedBalance',
+  'minDelegateAmount',
+  'unclaimedUndelegatedBalance',
+  'canClaimUndelegatedBalance',
+  'isUndelegateInProgress',
+  'validatorActivationTime',
+  'validatorExitTime',
+  'validatorWithdrawTime',
+  'liquidRewards',
+  'withdrawable',
+  'unbondNonce',
+  'minRewardsToWithdraw',
+])
+
+const isPlainObject = (value) =>
+  Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+
 export const createEthereumHooks = ({
   assetClientInterface,
   assetName,
-  stakingAssetNames,
+  stakingConfiguration,
   server,
+  now = () => performance.now(),
 }) => {
   assert(assetClientInterface, 'assetClientInterface is required')
   assert(server, 'server is required')
   assert(assetName, 'assetName is required')
-  const afterTickHook = async ({ walletAccount }) => {
-    // args passed from monitor tick method ({ monitor, error })
-    const assets = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: assetName,
-    })
-
-    // some assets may not be available
-    const stakingAssets = stakingAssetNames.map((assetName) => assets[assetName]).filter(Boolean)
-
+  assert(isPlainObject(stakingConfiguration), 'object stakingConfiguration is required')
+  const stakingAssetNames = Object.keys(stakingConfiguration)
+  for (const name of stakingAssetNames) {
+    const config = stakingConfiguration[name]
+    assert(isPlainObject(config), `expected object for ${name} staking configuration`)
+    const contracts = config.activityContracts
+    assert(
+      contracts === undefined ||
+        (Array.isArray(contracts) && contracts.every((address) => typeof address === 'string')),
+      `expected array of strings for ${name} activityContracts`
+    )
+  }
+  const freshness = new Map()
+  const addresses = new Map()
+  const generations = new Map()
+  const commits = new Map()
+  const afterTickHook = async ({ walletAccount, refresh = false }) => {
+    // Order requests at entry, not after address discovery: discovery itself can
+    // be delayed while a newer explicit refresh is already running.
+    const accountKey = String(walletAccount)
+    const generation = {}
+    generations.set(accountKey, generation)
+    const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: assetName })
+    const stakingAssets = stakingAssetNames.map((name) => assets[name]).filter(Boolean)
     const userAddress = await assetClientInterface.getReceiveAddress({
       assetName,
       walletAccount,
       useCache: true,
     })
-
-    const stakingInfo = {
-      staking: Object.create(null),
-    }
+    const address = userAddress.toString().toLowerCase()
+    if (generations.get(accountKey) !== generation) return
+    const addressChanged = addresses.get(accountKey) !== address
+    addresses.set(accountKey, address)
+    const baseTxLog = await assetClientInterface.getTxLog({ assetName, walletAccount })
+    const patches = Object.create(null)
+    const completed = []
 
     for (const asset of stakingAssets) {
-      const stakingAssetName = asset.name
-      const getStakingInfo =
-        stakingAssetName === 'polygon' ? getPolygonStakingInfo : getEthereumStakingInfo
+      const stakingApi = asset.api?.staking
+      if (!stakingApi?.getStakingInfo) continue
+      const key = JSON.stringify([String(walletAccount), assetName, asset.name, address])
+      const previous = freshness.get(key)
+      try {
+        const txLog =
+          asset.name === assetName
+            ? baseTxLog
+            : await assetClientInterface.getTxLog({ assetName: asset.name, walletAccount })
+        const { pending, fingerprint } = getStakingActivity({
+          assetName: asset.name,
+          activityContracts: stakingConfiguration[asset.name].activityContracts,
+          txLogs: [baseTxLog, txLog],
+        })
+        const force =
+          refresh || addressChanged || pending || !previous || previous.fingerprint !== fingerprint
+        if (!force && now() < previous.deadline) continue
 
-      // asset may not be enabled in the wallet
-      const assetStakingInfo = await getStakingInfo({
-        address: userAddress.toString(),
-        asset,
-        server,
-      })
-      stakingInfo.staking[stakingAssetName] = assetStakingInfo
+        patches[asset.name] = await stakingApi.getStakingInfo({
+          address,
+          background: true,
+          useCache: !force,
+          // Initial per-address discovery is full, but the queue is global.
+          useQueueCache:
+            !refresh && !pending && (!previous || previous.fingerprint === fingerprint),
+        })
+        completed.push([
+          key,
+          { fingerprint, deadline: now() + stakingStateInterval(patches[asset.name]) },
+        ])
+      } catch (error) {
+        // Keep the last successful account state and retry on the next normal
+        // tick. Never interpret transport/contract/provider failures as zero.
+        if (generations.get(accountKey) === generation) freshness.delete(key)
+        console.warn(`Failed to refresh ${asset.name} staking state`, error)
+      }
     }
 
-    const batch = assetClientInterface.createOperationsBatch()
-    assetClientInterface.updateAccountStateBatch({
-      assetName,
-      walletAccount,
-      newData: stakingInfo,
-      batch,
-    })
-
-    const processTxLogsPromises = stakingAssets.map((asset) => {
-      return processTxLog({
-        asset,
-        assetClientInterface,
+    const publish = async () => {
+      if (generations.get(accountKey) !== generation) return
+      const batch = assetClientInterface.createOperationsBatch()
+      // All asynchronous preparation is inside the per-account commit queue.
+      // Newer reads can run concurrently, but cannot commit ahead of an already
+      // executing batch. A superseded preparation is discarded before execute.
+      const current = await assetClientInterface.getAccountState({ assetName, walletAccount })
+      await Promise.all(
+        stakingAssets.map((asset) =>
+          processTxLog({
+            asset,
+            assetClientInterface,
+            walletAccount,
+            batch,
+          })
+        )
+      )
+      const latestAddress = await assetClientInterface.getReceiveAddress({
+        assetName,
         walletAccount,
-        batch,
-        server,
+        useCache: true,
       })
-    })
+      if (
+        latestAddress.toString().toLowerCase() !== address ||
+        generations.get(accountKey) !== generation
+      ) {
+        return
+      }
 
-    await Promise.all(processTxLogsPromises)
-    await assetClientInterface.executeOperationsBatch(batch)
+      const staking = { ...current.staking }
+      const owners = { ...current.stakingSnapshotOwners }
+      let changed = false
+      // Ownership is persisted with the snapshot, not inferred from in-memory
+      // deadlines. Unknown legacy owners cannot supply failed fields on restore.
+      // Preserve only non-service host metadata when changing snapshot owners.
+      for (const name of new Set([...stakingAssetNames, ...Object.keys(owners)])) {
+        if (owners[name]?.address !== address || owners[name]?.network !== assetName) {
+          staking[name] = Object.fromEntries(
+            Object.entries(staking[name] || {}).filter(([key]) => !STAKING_SNAPSHOT_FIELDS.has(key))
+          )
+          delete owners[name]
+          changed = true
+        }
+      }
+      for (const [name, patch] of Object.entries(patches)) {
+        staking[name] = { ...staking[name], ...patch }
+        owners[name] = { address, network: assetName }
+        changed = true
+      }
+      if (changed) {
+        assetClientInterface.updateAccountStateBatch({
+          assetName,
+          walletAccount,
+          newData: { staking, stakingSnapshotOwners: owners },
+          batch,
+        })
+      }
+      // No await between the final generation/address check and batch execution.
+      await assetClientInterface.executeOperationsBatch(batch)
+      // An in-flight storage commit cannot be cancelled through ACI. It is
+      // serialized before newer commits; never let it publish a stale deadline.
+      const committedAddress = await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+        useCache: true,
+      })
+      if (
+        generations.get(accountKey) === generation &&
+        committedAddress.toString().toLowerCase() === address
+      ) {
+        for (const [key, entry] of completed) freshness.set(key, entry)
+      }
+    }
+    const previousCommit = commits.get(accountKey) || Promise.resolve()
+    const commit = previousCommit.catch(() => {}).then(publish)
+    commits.set(accountKey, commit)
+    try {
+      await commit
+    } finally {
+      if (commits.get(accountKey) === commit) commits.delete(accountKey)
+    }
   }
 
   return {
+    // A restart/resume exposed through monitor.start must rediscover restored
+    // accounts. No host screen lifecycle is assumed; update({refresh:true}) and
+    // direct getStakingInfo({address}) are explicit uncached refresh paths.
+    'before-start': () => {
+      freshness.clear()
+      addresses.clear()
+      generations.clear()
+    },
     'after-tick': afterTickHook,
   }
 }

package/src/hooks/staking-freshness.js

@@ -0,0 +1,58 @@
+import { isPendingTxInLog } from '@exodus/ethereum-lib'
+
+const STAKING_FIELDS = ['delegate', 'undelegate', 'undelegatePending', 'claimUndelegate', 'rewards']
+
+// Inspect both logs: Polygon calls without token transfers only live in ETH's
+// log. Any interaction with a staking contract is conservatively relevant.
+export const getStakingActivity = ({ assetName, activityContracts = [], txLogs }) => {
+  const contracts = new Set(activityContracts.map((address) => address.toLowerCase()))
+  const isContract = (address) =>
+    typeof address === 'string' && contracts.has(address.toLowerCase())
+  const entries = new Map()
+  let pending = false
+  for (const txs of txLogs) {
+    for (const tx of txs) {
+      const relevant =
+        isContract(tx.to) ||
+        (Array.isArray(tx.from) ? tx.from.some(isContract) : isContract(tx.from)) ||
+        (tx.coinName === assetName &&
+          STAKING_FIELDS.some((field) => tx.data?.[field] !== undefined))
+      if (!relevant) continue
+      const isPending = isPendingTxInLog(tx)
+      pending ||= isPending
+      // Do not include increasing confirmation counts or processor-added metadata:
+      // neither constitutes a new staking event. Include block identity for reorgs.
+      entries.set(`${tx.coinName}:${tx.txId}`, [
+        tx.txId,
+        isPending,
+        tx.confirmations > 0,
+        tx.error || null,
+        !!tx.dropped,
+        tx.data?.replacedBy || null,
+        tx.data?.blockHash || tx.blockHash || null,
+        tx.data?.blockNumber || tx.blockHeight || null,
+      ])
+    }
+  }
+  return {
+    pending,
+    fingerprint: JSON.stringify([...entries].sort(([a], [b]) => a.localeCompare(b))),
+  }
+}
+
+export const stakingStateInterval = (info) => {
+  // A pending validator activation/exit is chain state, not a pending local tx.
+  // It must never keep a wallet on the one-minute transaction cadence forever.
+  const active =
+    info.isDelegating ||
+    info.isUndelegateInProgress ||
+    info.canClaimUndelegatedBalance ||
+    [
+      'delegatedBalance',
+      'pendingBalance',
+      'pendingDepositedBalance',
+      'unclaimedUndelegatedBalance',
+      'liquidRewards',
+    ].some((key) => info[key]?.isPositive)
+  return (active ? 5 : 15) * 60_000
+}