@exodus/ethereum-api 8.64.2 → 8.64.4

package/CHANGELOG.md

@@ -3,6 +3,24 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.64.4](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.3...@exodus/ethereum-api@8.64.4) (2026-02-09)
+
+**Note:** Version bump only for package @exodus/ethereum-api
+
+
+
+
+
+## [8.64.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.2...@exodus/ethereum-api@8.64.3) (2026-01-26)
+
+
+### Bug Fixes
+
+
+* fix: drop third party tx input from clarity tx log items (#7317)
+
+
+
 ## [8.64.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.64.1...@exodus/ethereum-api@8.64.2) (2026-01-23)
 
 **Note:** Version bump only for package @exodus/ethereum-api

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.64.2",
+  "version": "8.64.4",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "d6aa274a62e489f5dd27e11088c56b3a64903779"
+  "gitHead": "ebcc3fe022dfc1e21e3ccdc00faf0769e8fb3092"
 }

package/src/create-asset.js

@@ -37,7 +37,7 @@ import { getBalancesFactory } from './get-balances.js'
 import { getFeeFactory } from './get-fee.js'
 import { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
 import { serverBasedFeeMonitorFactoryFactory } from './server-based-fee-monitor.js'
-import { createStakingApi } from './staking-api.js'
+import { stakingApiFactory } from './staking/api/index.js'
 import { createTxFactory } from './tx-create.js'
 import { txSendFactory } from './tx-send/index.js'
 import { createWeb3API } from './web3/index.js'
@@ -63,7 +63,8 @@ export const createAssetFactory = ({
   monitorType: defaultMonitorType = 'magnifier',
   nfts: defaultNfts = false,
   serverUrl: defaultServerUrl,
-  stakingConfiguration = {},
+  stakingConfiguration = Object.create(null),
+  stakingDependencies = Object.create(null),
   useEip1191ChainIdChecksum = false,
   forceGasLimitEstimation = false,
   rpcBalanceAssetNames = [],
@@ -156,7 +157,16 @@ export const createAssetFactory = ({
     })
 
     const { createToken, getTokens } = createTokenFactory(
-      { address, bip44, keys, getBalances },
+      {
+        address,
+        bip44,
+        keys,
+        getBalances,
+        assetClientInterface,
+        server,
+        stakingConfiguration,
+        stakingDependencies,
+      },
       assets
     )
 
@@ -289,7 +299,17 @@ export const createAssetFactory = ({
       signHardware: signHardwareFactory({ baseAssetName: asset.name }),
       signMessage: ({ message, privateKey, signer }) =>
         signer ? signMessageWithSigner({ message, signer }) : signMessage({ privateKey, message }),
-      ...(supportsStaking && { staking: createStakingApi({ network: asset.name }) }),
+      ...(supportsStaking &&
+        stakingDependencies[asset.name] && {
+          staking: stakingApiFactory({
+            assetName: asset.name,
+            currency: asset.currency,
+            assetClientInterface,
+            server,
+            stakingConfiguration: stakingConfiguration[asset.name],
+            stakingDependencies: stakingDependencies[asset.name],
+          }),
+        }),
       validateAssetId: address.validate,
       web3: createWeb3API({ asset }),
     }

package/src/create-token-factory.js

@@ -2,12 +2,12 @@ import { ASSET_FAMILY } from '@exodus/assets'
 import { createContract } from '@exodus/ethereum-lib'
 import assert from 'minimalistic-assert'
 
+import { stakingApiFactory } from './staking/api/index.js'
 import {
   isPolygonClaimUndelegate,
   isPolygonDelegate,
   isPolygonUndelegate,
 } from './staking/matic/index.js'
-import { createStakingApi } from './staking-api.js'
 
 const defaultTokenFeatures = {
   family: ASSET_FAMILY.EVM,
@@ -35,31 +35,50 @@ const getPolygonActivityTxs = ({ txs }) =>
 const getActivityTxs = ({ txs }) => txs.filter((tx) => !smallbalanceTx(tx))
 
 const getCreateBaseToken =
-  ({ getBalances, ...props }) =>
+  ({
+    getBalances,
+    assetClientInterface,
+    server,
+    stakingConfiguration = Object.create(null),
+    stakingDependencies = Object.create(null),
+    ...props
+  }) =>
   ({ name, contract, features, ...tokenDef }) => {
     assert(getBalances, 'getBalances is required')
     const tokenSpecificFeatures = name === 'polygon' ? { staking: {} } : {}
-    const tokenSpecificApiFunctions =
-      name === 'polygon' ? { staking: createStakingApi({ network: name }) } : {}
 
     const tokenFeatures = { ...defaultTokenFeatures, ...features, ...tokenSpecificFeatures }
-    return {
+    const baseApi = {
+      getActivityTxs: name === 'polygon' ? getPolygonActivityTxs : getActivityTxs,
+      features: tokenFeatures,
+      hasFeature: (feature) => !!tokenFeatures[feature], // @deprecated use api.features instead
+      getBalances,
+      getTxLogFilter: name === 'polygon' ? getPolygonTxLogFilter : getTxLogFilter,
+    }
+
+    const tokenAsset = {
       ...tokenDef,
       addresses: contract,
       assetId: contract.current.toLowerCase(),
       contract: createContract(contract.current, name),
       gasLimit: 120_000,
       name,
-      api: {
-        getActivityTxs: name === 'polygon' ? getPolygonActivityTxs : getActivityTxs,
-        features: tokenFeatures,
-        hasFeature: (feature) => !!tokenFeatures[feature], // @deprecated use api.features instead
-        getBalances,
-        getTxLogFilter: name === 'polygon' ? getPolygonTxLogFilter : getTxLogFilter,
-        ...tokenSpecificApiFunctions,
-      },
-      ...props, // override props above, add new props
+      api: baseApi,
+      ...props,
     }
+
+    if (name === 'polygon' && stakingDependencies[name]) {
+      baseApi.staking = stakingApiFactory({
+        assetName: tokenAsset.name,
+        currency: tokenAsset.currency,
+        assetClientInterface,
+        server,
+        stakingConfiguration: stakingConfiguration[name],
+        stakingDependencies: stakingDependencies[name],
+      })
+    }
+
+    return tokenAsset
   }
 
 export const createTokenFactory = (props, assets) => {

package/src/get-balances.js

@@ -14,7 +14,7 @@ import { getLatestCanonicalAbsoluteBalanceTx } from './tx-log/clarity-utils/inde
  * Missing fields that should be added to getBalancesFactory return value:
  *
  * 1. `rewards` / `liquidRewards` - Currently, accountState.staking[asset.name] contains
- *    rewardsBalance and liquidRewards (from getPolygonStakingInfo / getEthereumStakingInfo),
+ *    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().
  *

package/src/hooks/monitor.js

@@ -1,6 +1,5 @@
 import assert from 'minimalistic-assert'
 
-import { getEthereumStakingInfo, getPolygonStakingInfo } from '../staking/index.js'
 import processTxLog from '../tx-log-staking-processor/index.js'
 
 export const createEthereumHooks = ({
@@ -32,17 +31,13 @@ export const createEthereumHooks = ({
     }
 
     for (const asset of stakingAssets) {
-      const stakingAssetName = asset.name
-      const getStakingInfo =
-        stakingAssetName === 'polygon' ? getPolygonStakingInfo : getEthereumStakingInfo
+      const stakingApi = asset.api?.staking
+      if (!stakingApi?.getStakingInfo) continue
 
-      // asset may not be enabled in the wallet
-      const assetStakingInfo = await getStakingInfo({
+      const assetStakingInfo = await stakingApi.getStakingInfo({
         address: userAddress.toString(),
-        asset,
-        server,
       })
-      stakingInfo.staking[stakingAssetName] = assetStakingInfo
+      stakingInfo.staking[asset.name] = assetStakingInfo
     }
 
     const batch = assetClientInterface.createOperationsBatch()

package/src/index.js

@@ -26,17 +26,24 @@ export {
   DEFAULT_GAS_LIMIT_MULTIPLIER,
   estimateGasLimit,
   fetchGasLimit,
+  scaleGasLimitEstimate,
 } from './gas-estimation.js'
 
 export { createEvmServer, getServer } from './exodus-eth-server/index.js'
 
-export { EthereumMonitor, EthereumNoHistoryMonitor, ClarityMonitor } from './tx-log/index.js'
+export {
+  EthereumMonitor,
+  EthereumNoHistoryMonitor,
+  ClarityMonitor,
+  getOptimisticTxLogEffects,
+} from './tx-log/index.js'
 
 export { getStakingHistoryBalance, getBalancesFactory } from './get-balances.js'
 
 export {
   FantomStaking,
   stakingProviderClientFactory,
+  ethereumStakingDeps,
   getEthereumStakingInfo,
   createEthereumStakingService,
   EthereumStaking,
@@ -46,8 +53,6 @@ export {
   isEthereumUndelegate,
   isEthereumClaimUndelegate,
   MaticStakingApi,
-  createPolygonStakingService,
-  getPolygonStakingInfo,
   isPolygonTx,
   isPolygonDelegate,
   isPolygonUndelegate,
@@ -71,6 +76,8 @@ export {
 
 export { estimateL1DataFeeFactory, getL1GetFeeFactory } from './optimism-gas/index.js'
 
+export { getAggregateTransactionPricing } from './get-fee.js'
+
 export {
   fromHexToString,
   fromHexToBigInt,

package/src/staking/api/index.js

@@ -1,14 +1,15 @@
-import { pick } from '@exodus/basic-utils'
 import assert from 'minimalistic-assert'
 
 export const stakingApiFactory = ({
-  asset,
+  assetName,
+  currency,
   assetClientInterface,
   server, // coin node server
   stakingConfiguration,
   stakingDependencies,
 }) => {
-  assert(asset, '"asset" is required')
+  assert(assetName, '"assetName" is required')
+  assert(currency, '"currency" is required')
   assert(assetClientInterface, '"assetClientInterface" is required')
   assert(server, '"server" is required')
   assert(stakingConfiguration, '"stakingConfiguration" is required')
@@ -17,7 +18,7 @@ export const stakingApiFactory = ({
   const { contracts, minAmount } = stakingConfiguration
   const { stakingServerFactory, stakingServiceFactory } = stakingDependencies
 
-  const stakingServer = stakingServerFactory({ asset, server, minAmount, contracts })
+  const stakingServer = stakingServerFactory({ assetName, currency, server, minAmount, contracts })
 
   const stakingService = stakingServiceFactory({
     assetClientInterface,
@@ -26,9 +27,9 @@ export const stakingApiFactory = ({
   })
 
   return {
+    ...stakingService,
     isStaking: async ({ isDelegating }) => isDelegating,
     isUnstaking: async ({ isUndelegateInProgress }) => isUndelegateInProgress,
     isUnstaked: async ({ canClaimUndelegateBalance }) => canClaimUndelegateBalance,
-    ...pick(stakingService, ['approveStake', 'stake', 'unstake', 'claimUnstaked', 'claimRewards']),
   }
 }

package/src/staking/ethereum/api.js

@@ -42,20 +42,21 @@ export class EthereumStaking {
   }
 
   constructor(
-    asset, // ethereum or ethereumholesky for testnet
+    assetName, // ethereum or ethereumholesky for testnet
+    currency,
     minAmount = MIN_AMOUNT,
     server
   ) {
-    this.asset = asset
+    this.asset = { name: assetName, currency }
     const accountingAddress =
-      EthereumStaking.addresses[asset.name].EVERSTAKE_ADDRESS_CONTRACT_ACCOUNTING
-    const poolAddress = EthereumStaking.addresses[asset.name].EVERSTAKE_ADDRESS_CONTRACT_POOL
+      EthereumStaking.addresses[assetName].EVERSTAKE_ADDRESS_CONTRACT_ACCOUNTING
+    const poolAddress = EthereumStaking.addresses[assetName].EVERSTAKE_ADDRESS_CONTRACT_POOL
 
     this.contractAccounting = createContract(accountingAddress, 'ethStakingAccounting')
     this.contractPool = createContract(poolAddress, 'ethStakingPool')
     this.accountingAddress = accountingAddress
     this.poolAddress = poolAddress
-    this.minAmount = asset.currency.defaultUnit(minAmount)
+    this.minAmount = currency.defaultUnit(minAmount)
     this.server = server
   }
 

package/src/staking/ethereum/deps.js

@@ -0,0 +1,33 @@
+import { EthereumStaking } from './api.js'
+import { createEthereumStakingService, getEthereumStakingInfo } from './service.js'
+
+/** Staking server factory for ethereum (used by stakingApiFactory). */
+export const stakingServerFactory = ({ assetName, currency, server, minAmount }) =>
+  new EthereumStaking(assetName, currency, minAmount, server)
+
+/** Staking service factory for ethereum (used by stakingApiFactory). */
+export const stakingServiceFactory = ({ assetClientInterface, server, stakingServer }) => {
+  const service = createEthereumStakingService({
+    assetName: stakingServer.asset.name,
+    assetClientInterface,
+  })
+
+  return {
+    ...service,
+    getStakingInfo: ({ address }) =>
+      getEthereumStakingInfo({
+        address,
+        asset: stakingServer.asset,
+        server,
+      }),
+    stake: service.delegate,
+    unstake: service.undelegate,
+    claimUnstaked: service.claimUndelegatedBalance,
+  }
+}
+
+/** Staking deps for ethereum base asset (plugin can pass as stakingDependencies.ethereum). */
+export const ethereumStakingDeps = {
+  stakingServerFactory,
+  stakingServiceFactory,
+}

package/src/staking/ethereum/index.js

@@ -1,3 +1,4 @@
 export * from './staking-utils.js'
 export * from './api.js'
 export * from './service.js'
+export { ethereumStakingDeps } from './deps.js'

package/src/staking/ethereum/service.js

@@ -32,7 +32,7 @@ const STAKING_OPERATION_FALLBACK_FEE_ESTIMATES = {
 }
 
 const getStakingApi = memoize(
-  (asset) => new EthereumStaking(asset, undefined, asset.server),
+  (asset) => new EthereumStaking(asset.name, asset.currency, undefined, asset.server),
   (asset) => asset.name
 )
 
@@ -569,9 +569,9 @@ export function createEthereumStakingService({
 }
 
 export async function getEthereumStakingInfo({ address, asset, server }) {
-  const { currency } = asset
+  const { name: assetName, currency } = asset
   const delegator = address.toLowerCase()
-  const staking = new EthereumStaking(asset, undefined, server)
+  const staking = new EthereumStaking(assetName, currency, undefined, server)
 
   const [
     activeStakedBalance,

package/src/staking/matic/index.js

@@ -1,5 +1,4 @@
 export { MaticStakingApi } from './api.js'
-export { createPolygonStakingService, getPolygonStakingInfo } from './service.js'
 export {
   isPolygonTx,
   isPolygonDelegate,

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

@@ -39,7 +39,7 @@ export default function getLogItemsFromServerTx({
   const methodId = serverTx.input && {
     methodId: serverTx.input.slice(0, Math.max(0, METHOD_ID_LENGTH)),
   }
-  const data = serverTx.input || '0x'
+  const data = (ourWalletWasSender ? serverTx.input : methodId?.methodId) || '0x'
   const walletUpdates = getWalletUpdates(ourWalletAddress, serverTx.walletChanges || [])
   const { baseBalanceUpdate, nonceUpdate, tokenBalancesUpdate } = walletUpdates
 

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

@@ -6,8 +6,18 @@ import { isEthereumStakingTx } from '../staking/ethereum/staking-utils.js'
 import { MaticStakingApi } from '../staking/matic/api.js'
 
 const polygonStakingApi = new MaticStakingApi()
-const ethereumStakingApi = new EthereumStaking(ethereum)
-const ethereumHoleskyStakingApi = new EthereumStaking(ethereumholesky)
+const ethereumStakingApi = new EthereumStaking(
+  ethereum.name,
+  ethereum.currency,
+  undefined,
+  undefined
+)
+const ethereumHoleskyStakingApi = new EthereumStaking(
+  ethereumholesky.name,
+  ethereumholesky.currency,
+  undefined,
+  undefined
+)
 
 export const decodePolygonStakingTxInputAmount = (tx) => {
   const {

package/src/staking/matic/service.js

@@ -1,599 +0,0 @@
-import { memoize } from '@exodus/basic-utils'
-
-import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
-import { getAggregateTransactionPricing } from '../../get-fee.js'
-import { getOptimisticTxLogEffects } from '../../tx-log/get-optimistic-txlog-effects.js'
-import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
-import { stakingProviderClientFactory } from '../staking-provider-client.js'
-import {
-  amountToCurrency,
-  DISABLE_BALANCE_CHECKS,
-  resolveFeeData as defaultResolveFeeData,
-} from '../utils/index.js'
-import { MaticStakingApi } from './api.js'
-import { maticDelegateSimulateTransactions } from './matic-staking-utils.js'
-
-const createStakingApiForFeeAsset = ({ feeAsset: { server } }) =>
-  new MaticStakingApi(undefined, undefined, server)
-
-// TODO: This should be `createMaticStakingService` to avoid confusion with Polygon staking.
-export function createPolygonStakingService({
-  assetClientInterface,
-  createWatchTx = defaultCreateWatch,
-  stakingProvider = stakingProviderClientFactory(),
-}) {
-  const assetName = 'ethereum'
-
-  const getStakeAssets = memoize(async () => {
-    const { polygon: asset, [assetName]: feeAsset } =
-      await assetClientInterface.getAssetsForNetwork({
-        baseAssetName: assetName,
-      })
-    return { asset, feeAsset }
-  })
-
-  const createStakingApi = memoize(async () => {
-    const { asset, feeAsset } = await getStakeAssets()
-    return { asset, feeAsset, stakingApi: createStakingApiForFeeAsset({ feeAsset }) }
-  })
-
-  // Helper function which selects the correct `asset` to use for when
-  // determining `feeData` for MATIC staking.
-  const resolveFeeData = async ({ feeData }) => {
-    const { feeAsset } = await getStakeAssets()
-    return defaultResolveFeeData({ asset: feeAsset, assetClientInterface, feeData })
-  }
-
-  const getLatestFeeData = async () => {
-    const { feeAsset } = await getStakeAssets()
-    return assetClientInterface.getFeeData({ assetName: feeAsset.name })
-  }
-
-  const resolveOptionalFeeData = async ({ feeData }) => {
-    // If the caller provides truthy `feeData`, we can continue
-    // as normal.
-    if (feeData) return feeData
-
-    // If the caller specifically omits `feeData`, then we
-    // provide a backup without warning. This is useful for
-    // calls with no expectations on the caller to provide
-    // `feeData`, i.e. one-shot transactions, or transactions
-    // which do not render a fee estimation.
-    return getLatestFeeData()
-  }
-
-  const getDelegatorAddress = async ({ walletAccount }) => {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    return address.toLowerCase()
-  }
-
-  /**
-   * Delegate MATIC tokens for staking.
-   * @param {walletAccount} params.walletAccount - The walletAccount for the delegator (required).
-   * @param {NumberUnit} params.amount - The amount of MATIC to delegate (required).
-   * @param {FeeData} params.feeData - Optional feeData to use for the transaction (optional, if not provided will be obtained from the asset client interface).
-   * @param {Boolean} params.revertOnSimulationError - Optional boolean to revert on simulation error (optional, default is true). Allows us to quickly react to simulator issues.
-   */
-  async function delegate({ walletAccount, amount, feeData, revertOnSimulationError = true }) {
-    const [delegatorAddress, { asset, stakingApi }, resolvedFeeData] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-      resolveFeeData({ feeData }),
-    ])
-
-    feeData = resolvedFeeData
-
-    const baseNonce = await asset.baseAsset.getNonce({
-      asset,
-      fromAddress: delegatorAddress.toString(),
-      walletAccount,
-    })
-
-    const [txApproveData, txDelegateData] = await Promise.all([
-      stakingApi.approveStakeManager(amount),
-      stakingApi.delegate({ amount }),
-    ])
-
-    const {
-      gasPrice,
-      gasLimit: approveGasLimit,
-      tipGasPrice,
-    } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.polygonContract.address,
-      txInput: txApproveData,
-      feeData,
-    })
-
-    // Estimate based on the average gas usage for the delegate transaction. 250000 is the average.
-    const { gasLimit: estimatedDelegateGasLimit } = await estimateDelegateTxFee({
-      feeData,
-    })
-
-    const createTxBaseArgs = {
-      asset: asset.baseAsset,
-      walletAccount,
-      fromAddress: delegatorAddress.toString(),
-      amount: asset.baseAsset.currency.ZERO,
-      tipGasPrice,
-      gasPrice,
-    }
-    const [unsignedTxApprove, unsignedTxDelegate] = await Promise.all([
-      asset.baseAsset.api.createTx({
-        ...createTxBaseArgs,
-        toAddress: stakingApi.polygonContract.address,
-        txInput: txApproveData,
-        gasLimit: approveGasLimit,
-        nonce: baseNonce,
-      }),
-      asset.baseAsset.api.createTx({
-        ...createTxBaseArgs,
-        toAddress: stakingApi.validatorShareContract.address,
-        txInput: txDelegateData,
-        gasLimit: estimatedDelegateGasLimit,
-        nonce: baseNonce + 1,
-      }),
-    ])
-
-    await maticDelegateSimulateTransactions({
-      asset,
-      unsignedTxApprove,
-      unsignedTxDelegate,
-      senderAddress: delegatorAddress.toString(),
-      revertOnSimulationError,
-    })
-
-    // Sign transactions
-    const [approveSigned, delegateSigned] = await Promise.all([
-      assetClientInterface.signTransaction({
-        assetName: asset.baseAsset.name,
-        unsignedTx: unsignedTxApprove.unsignedTx,
-        walletAccount,
-      }),
-      assetClientInterface.signTransaction({
-        assetName: asset.baseAsset.name,
-        unsignedTx: unsignedTxDelegate.unsignedTx,
-        walletAccount,
-      }),
-    ])
-
-    // Pre-compute txIDs
-    const approveTxId = `0x${approveSigned.txId.toString('hex')}`
-    const delegateTxId = `0x${delegateSigned.txId.toString('hex')}`
-
-    const bundleResponse = await asset.baseAsset.broadcastPrivateBundle({
-      txs: [approveSigned, delegateSigned].map(({ rawTx }) => rawTx),
-    })
-    const bundleHash = bundleResponse?.bundleHash
-
-    const { optimisticTxLogEffects: approveOptimisticTxLogEffects } =
-      await getOptimisticTxLogEffects({
-        asset: asset.baseAsset,
-        assetClientInterface,
-        fromAddress: delegatorAddress.toString(),
-        txId: approveTxId,
-        unsignedTx: unsignedTxApprove.unsignedTx,
-        walletAccount,
-        bundleId: bundleHash ?? undefined,
-      })
-
-    const { optimisticTxLogEffects: delegateOptimisticTxLogEffects } =
-      await getOptimisticTxLogEffects({
-        asset: asset.baseAsset,
-        assetClientInterface,
-        fromAddress: delegatorAddress.toString(),
-        txId: delegateTxId,
-        unsignedTx: unsignedTxDelegate.unsignedTx,
-        walletAccount,
-        bundleId: bundleHash ?? undefined,
-      })
-    // Combine optimistic effects from both transactions
-    const tokenOptimisticEffects = [
-      ...approveOptimisticTxLogEffects,
-      ...delegateOptimisticTxLogEffects,
-    ]
-
-    for (const optimisticEffect of tokenOptimisticEffects) {
-      await assetClientInterface.updateTxLogAndNotify(optimisticEffect)
-    }
-
-    await stakingProvider.notifyStaking({
-      txId: delegateTxId,
-      asset: asset.name,
-      delegator: delegatorAddress,
-      amount: amount.toBaseString(),
-    })
-    return delegateTxId
-  }
-
-  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false }) {
-    feeData = await resolveOptionalFeeData({ feeData })
-
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
-
-    amount = amountToCurrency({ asset, amount })
-
-    const txUndelegateData = await stakingApi.undelegate({ amount })
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress.toLowerCase(),
-      to: stakingApi.validatorShareContract.address,
-      txInput: txUndelegateData,
-      feeData,
-    })
-
-    return prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txUndelegateData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      feeData,
-      waitForConfirmation,
-    })
-  }
-
-  async function claimRewards({ walletAccount, feeData }) {
-    feeData = await resolveOptionalFeeData({ feeData })
-
-    const [delegatorAddress, { stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
-
-    const txWithdrawRewardsData = await stakingApi.withdrawRewards()
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: txWithdrawRewardsData,
-      feeData,
-    })
-    return prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txWithdrawRewardsData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      feeData,
-    })
-  }
-
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData }) {
-    feeData = await resolveOptionalFeeData({ feeData })
-
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
-
-    const { currency } = asset
-    const unstakedClaimInfo = await fetchUnstakedClaimInfo({
-      stakingApi,
-      delegator: delegatorAddress,
-    })
-
-    const { unclaimedUndelegatedBalance } = await getUnstakedUnclaimedInfo({
-      stakingApi,
-      currency,
-      delegator: delegatorAddress,
-      ...unstakedClaimInfo,
-    })
-
-    const txClaimUndelegatedData = await stakingApi.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: txClaimUndelegatedData,
-      feeData,
-    })
-    const txId = await prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txClaimUndelegatedData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      feeData,
-    })
-
-    await stakingProvider.notifyUnstaking({
-      txId,
-      asset: asset.name,
-      delegator: delegatorAddress,
-      amount: unclaimedUndelegatedBalance.toBaseString(),
-    })
-
-    return txId
-  }
-
-  async function estimateDelegateOperation({
-    walletAccount,
-    operation,
-    args,
-    // NOTE: When estimating transactions, ideally we'd expect the `feeData`
-    //       that we intend to send the transaction using. If this is not
-    //       defined, we'll fallback to a default (with a warning).
-    feeData,
-  }) {
-    // HACK: For delegation transactions, we must fall back to the
-    //       custom implementation, since we can't currently estimate
-    //       the transaction due to a dependence upon approvals.
-    if (operation === 'delegate') return estimateDelegateTxFee({ feeData })
-
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
-      getDelegatorAddress({ walletAccount }),
-      createStakingApi(),
-    ])
-
-    feeData = await resolveFeeData({ feeData })
-
-    const delegateOperation = stakingApi[operation]
-    if (!delegateOperation) return
-
-    const { amount } = args
-    if (amount) {
-      args = { ...args, amount: amountToCurrency({ asset, amount }) }
-    }
-
-    const operationTxData = await delegateOperation({ ...args, walletAccount })
-    const { fee } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: operationTxData,
-      feeData,
-    })
-
-    return fee
-  }
-
-  /**
-   * Estimating delegete tx using {estimateGasLimit} function does not work
-   * as the execution reverts (due to missing MATIC approval).
-   * Instead, a fixed gas limit is use, which is:
-   *
-   * delegateGasLimit = ERC20ApproveGas + delegateGas
-   *
-   * This is just for displaying purposes and it's just an aproximation of the delegate gas cost,
-   * NOT the real fee cost
-   */
-  async function estimateDelegateTxFee({ feeData } = Object.create(null)) {
-    // approx gas limits
-    const { ethereum } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum',
-    })
-
-    feeData = await resolveFeeData({ feeData })
-
-    // TODO: update estimation to use a mock source address for
-    //       deposits so we can simulate the necessary approvals,
-    //       we shouldn't maintain constants like these
-    const erc20ApproveGas = 80_000
-    const delegateGas = 250_000
-
-    const { gasPrice } = getAggregateTransactionPricing({ baseAsset: ethereum, feeData })
-
-    const gasLimitWithBuffer = scaleGasLimitEstimate({
-      estimatedGasLimit: BigInt(erc20ApproveGas + delegateGas),
-    })
-
-    const fee = BigInt(gasLimitWithBuffer) * BigInt(gasPrice.toBaseNumber())
-
-    return {
-      gasLimit: gasLimitWithBuffer,
-      gasPrice,
-      fee: ethereum.currency.baseUnit(fee.toString()),
-    }
-  }
-
-  async function estimateTxFee({ from, to, txInput, feeData }) {
-    const { ethereum } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum',
-    })
-
-    const amount = ethereum.currency.ZERO
-
-    const gasLimit = await estimateGasLimit({
-      asset: ethereum,
-      fromAddress: from,
-      toAddress: to,
-      amount, // staking contracts does not require ETH amount to interact with
-      data: txInput,
-      gasPrice: DISABLE_BALANCE_CHECKS,
-    })
-
-    const fee = ethereum.api.getFee({ asset: ethereum, feeData, gasLimit, amount })
-    return { ...fee, gasLimit }
-  }
-
-  async function prepareAndSendTx({
-    walletAccount,
-    to,
-    txData: txInput,
-    gasPrice,
-    gasLimit,
-    tipGasPrice,
-    waitForConfirmation = false,
-    feeData,
-  }) {
-    const { ethereum: asset } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum',
-    })
-    const sendTxArgs = {
-      asset,
-      walletAccount,
-      address: to,
-      amount: asset.currency.ZERO,
-      txInput,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      waitForConfirmation,
-      feeData,
-    }
-
-    const { txId } = await asset.baseAsset.api.sendTx(sendTxArgs)
-
-    const baseAsset = asset.baseAsset
-    if (waitForConfirmation) {
-      const getTxLog = (...args) => assetClientInterface.getTxLog(...args)
-      const watchTx = createWatchTx({
-        walletAccount,
-        getTxLog,
-        baseAsset,
-      })
-      await watchTx(txId)
-    }
-
-    return txId
-  }
-
-  return {
-    delegate,
-    undelegate,
-    claimRewards,
-    claimUndelegatedBalance,
-    getPolygonStakingInfo,
-    estimateDelegateTxFee,
-    estimateDelegateOperation,
-  }
-}
-
-async function fetchUnstakedClaimInfo({ stakingApi, delegator }) {
-  const [unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate] = await Promise.all([
-    stakingApi.getCurrentUnbondNonce(delegator),
-    stakingApi.getWithdrawalDelay(),
-    stakingApi.getCurrentCheckpoint(),
-    stakingApi.getWithdrawExchangeRate(),
-  ])
-
-  return {
-    unbondNonce,
-    withdrawalDelay,
-    currentEpoch,
-    withdrawExchangeRate,
-  }
-}
-
-function calculateUnclaimedTokens({
-  currency,
-  exchangeRatePrecision,
-  withdrawExchangeRate,
-  shares,
-  canClaimUndelegatedBalance,
-  isUndelegateInProgress,
-}) {
-  // see contract implementation
-  // https://github.com/maticnetwork/contracts/blob/1eb6960e511a967c15d4936904570a890d134fa6/contracts/staking/validatorShare/ValidatorShare.sol#L304
-  if (canClaimUndelegatedBalance || isUndelegateInProgress) {
-    const unclaimedTokens = withdrawExchangeRate
-      .mul(shares) // shares === validator tokens
-      .div(exchangeRatePrecision)
-      .toString()
-
-    return currency.baseUnit(unclaimedTokens)
-  }
-
-  return currency.ZERO
-}
-
-function canClaimUndelegatedBalance({ shares, withdrawEpoch, isUndelegateInProgress }) {
-  const undelegateNotStarted = shares.isZero() && withdrawEpoch.isZero()
-  return !(isUndelegateInProgress || undelegateNotStarted)
-}
-
-async function getUnstakedUnclaimedInfo({
-  stakingApi,
-  currency,
-  delegator,
-  unbondNonce,
-  currentEpoch,
-  withdrawalDelay,
-  withdrawExchangeRate,
-}) {
-  const { withdrawEpoch, shares } = await stakingApi.getUnboundInfo(delegator, unbondNonce)
-  const exchangeRatePrecision = stakingApi.EXCHANGE_RATE_PRECISION
-  const isUndelegateInProgress =
-    !withdrawEpoch.isZero() && withdrawEpoch.add(withdrawalDelay).gte(currentEpoch)
-  const isUndelegatedBalanceClaimable = canClaimUndelegatedBalance({
-    shares,
-    withdrawEpoch,
-    isUndelegateInProgress,
-  })
-  const unclaimedUndelegatedBalance = calculateUnclaimedTokens({
-    currency,
-    exchangeRatePrecision,
-    withdrawExchangeRate,
-    shares,
-    canClaimUndelegatedBalance: isUndelegatedBalanceClaimable,
-    isUndelegateInProgress,
-  })
-  return {
-    isUndelegateInProgress,
-    canClaimUndelegatedBalance: isUndelegatedBalanceClaimable,
-    unclaimedUndelegatedBalance,
-  }
-}
-
-async function fetchRewardsInfo({ stakingApi, delegator, currency }) {
-  const [minRewardsToWithdraw, lastRewards, rewardsBalance] = await Promise.all([
-    stakingApi.getMinRewardsToWithdraw(),
-    stakingApi.getLiquidRewards(delegator),
-    stakingApi.getTotalRewards(delegator),
-  ])
-  const withdrawable = lastRewards.sub(minRewardsToWithdraw).gte(currency.ZERO)
-    ? lastRewards
-    : currency.ZERO
-
-  return {
-    rewardsBalance: rewardsBalance.add(lastRewards), // all time accrued rewards
-    liquidRewards: lastRewards, // current pending rewards (on-chain)
-    minRewardsToWithdraw,
-    withdrawable, // unclaimed rewards
-  }
-}
-
-export async function getPolygonStakingInfo({ address, asset: { currency, baseAsset: feeAsset } }) {
-  const stakingApi = createStakingApiForFeeAsset({ feeAsset })
-  const delegator = address.toLowerCase()
-  const [
-    delegatedBalance,
-    { rewardsBalance, liquidRewards, minRewardsToWithdraw, withdrawable },
-    { unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate },
-  ] = await Promise.all([
-    stakingApi.getTotalStake(delegator),
-    fetchRewardsInfo({ stakingApi, delegator, currency }),
-    fetchUnstakedClaimInfo({ stakingApi, delegator }),
-  ])
-  const minDelegateAmount = currency.defaultUnit(1)
-  const isDelegating = !delegatedBalance.isZero
-
-  const unclaimedUndelegatedInfo = await getUnstakedUnclaimedInfo({
-    stakingApi,
-    currency,
-    delegator,
-    unbondNonce,
-    currentEpoch,
-    withdrawalDelay,
-    withdrawExchangeRate,
-  })
-
-  return {
-    rewardsBalance,
-    liquidRewards,
-    withdrawable,
-    unbondNonce,
-    isDelegating,
-    delegatedBalance,
-    activeStakedBalance: delegatedBalance,
-    minRewardsToWithdraw,
-    minDelegateAmount,
-    ...unclaimedUndelegatedInfo,
-  }
-}

package/src/staking-api.js

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