@exodus/ethereum-api 7.2.1 → 7.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "7.2.1",
+  "version": "7.3.1",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -20,12 +20,17 @@
   },
   "dependencies": {
     "@exodus/asset-lib": "^4.1.0",
+    "@exodus/assets": "^9.1.1",
+    "@exodus/basic-utils": "^2.1.0",
+    "@exodus/bip44-constants": "^195.0.0",
     "@exodus/crypto": "^1.0.0-rc.0",
     "@exodus/currency": "^2.1.3",
     "@exodus/ethereum-lib": "^4.2.7",
     "@exodus/ethereum-meta": "^1.2.0",
+    "@exodus/ethereumholesky-meta": "^1.0.1",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.7",
-    "@exodus/fetch": "^1.3.0-beta.4",
+    "@exodus/fetch": "^1.3.0",
+    "@exodus/key-utils": "^3.1.0",
     "@exodus/models": "^11.0.0",
     "@exodus/simple-retry": "^0.0.6",
     "@exodus/solidity-contract": "^1.1.3",
@@ -46,11 +51,11 @@
     "@exodus/bsc-meta": "^1.1.2",
     "@exodus/ethereumarbone-meta": "^1.1.5",
     "@exodus/ethereumgoerli-meta": "^1.0.3",
+    "@exodus/ethereumsepolia-meta": "^1.0.1",
     "@exodus/fantommainnet-meta": "^1.0.5",
     "@exodus/rootstock-meta": "^1.0.5",
-    "bignumber.js": "9.0.1",
     "cross-fetch": "^3.1.5",
     "delay": "4.0.1"
   },
-  "gitHead": "4e7cc9a7bf33f63f1b957005a75163a9f08f39f6"
+  "gitHead": "c09304326cb0fa6a3acd22d87c38553e05e43569"
 }

package/src/address-has-history.js

@@ -0,0 +1,6 @@
+export const addressHasHistoryFactory =
+  ({ server }) =>
+  async (address) => {
+    const history = await server.getHistoryV2(address, { index: 0, limit: 1 })
+    return history.length > 0
+  }

package/src/create-asset.js

@@ -0,0 +1,216 @@
+import { connectAssetsList } from '@exodus/assets'
+import { pick } from '@exodus/basic-utils'
+import bip44Constants from '@exodus/bip44-constants/by-ticker'
+import { getBalances } from './get-balances'
+import { ClarityMonitor } from './tx-log/clarity-monitor'
+import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor'
+import { EthereumMonitor } from './tx-log/ethereum-monitor'
+
+import { getServer } from './exodus-eth-server'
+
+import {
+  CONFIRMATIONS_NUMBER,
+  createEthereumLikeAccountState,
+  createGetKeyIdentifier as defaultCreateGetKeyIdentifier,
+  createUnsignedTx,
+  encodePrivate,
+  encodePublic,
+  hasChecksum,
+  parseUnsignedTx,
+  signUnsignedTx,
+  signUnsignedTxWithSigner,
+  validate,
+  signMessage,
+  signHardwareFactory,
+  DEFAULT_FEE_MONITOR_INTERVAL,
+} from '@exodus/ethereum-lib'
+import { ETHEREUM_LIKE_MONITOR_TYPES } from '@exodus/ethereum-lib/src/constants'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { addressHasHistoryFactory } from './address-has-history'
+import { createTokenFactory } from './create-token-factory'
+import { getEffectiveGasPrice, getFeeFactory } from './get-fee'
+import { createEthereumHooks } from './hooks'
+import { createStakingApi } from './staking-api'
+import { txSendFactory } from './tx-send'
+import { signMessageWithSigner } from '@exodus/ethereum-lib/src/sign-message'
+import { serverBasedFeeMonitorFactoryFactory } from './fee-monitor'
+
+export const createAssetFactory = ({
+  assetsList,
+  feeData,
+  AccountState: CustomAccountState,
+  monitorInterval,
+  nfts = false,
+  getFee: customGetFee,
+  useEip1191ChainIdChecksum = false,
+  customTokens = true,
+  isTestnet = false,
+  isMaxFeeAsset = false,
+  erc20FuelBuffer,
+  fuelThreshold,
+  customBip44,
+  customCreateGetKeyIdentifier,
+  feeMonitorInterval,
+}) => {
+  assert(assetsList, 'assetsList is required')
+  assert(feeData, 'feeData is required')
+
+  const base = assetsList.find((asset) => asset.name === asset.baseAssetName)
+  assert(base, 'base is required')
+
+  const createGetKeyIdentifier = customCreateGetKeyIdentifier || defaultCreateGetKeyIdentifier
+
+  return (
+    {
+      assetClientInterface,
+      config = {
+        allowMetaMaskCompat: false,
+        supportsStaking: false,
+      },
+      overrideCallback = ({ asset }) => asset,
+    } = Object.create(null)
+  ) => {
+    const assets = connectAssetsList(assetsList)
+
+    const { allowMetaMaskCompat, supportsStaking } = config
+
+    const asset = assets[base.name]
+
+    const server = getServer(asset)
+
+    const gasLimit = 21e3 // 21 KGas, enough only for sending ether to normal address
+
+    const contractGasLimit = 1e6 // used when estimateGas fail
+
+    const address = {
+      validate: useEip1191ChainIdChecksum
+        ? (address) => validate(address, { baseAssetName: asset.name })
+        : validate,
+      hasChecksum,
+      isContract: server.isContract,
+    }
+
+    const bip44 = customBip44 || bip44Constants['ETH']
+
+    const keys = {
+      encodePrivate,
+      encodePublic: useEip1191ChainIdChecksum
+        ? (pubKey) => encodePublic(pubKey, { baseAssetName: asset.name })
+        : encodePublic,
+    }
+
+    const { createToken, getTokens } = createTokenFactory({ address, bip44, keys }, assets)
+
+    const addressHasHistory = addressHasHistoryFactory({ server })
+
+    const monitorType = ETHEREUM_LIKE_MONITOR_TYPES[asset.name]
+
+    assert(monitorType, `ETHEREUM_LIKE_MONITOR_TYPES for asset ${asset.name} is not defined`)
+
+    const feeMonitor = monitorType === 'no-history'
+
+    const createFeeMonitor = serverBasedFeeMonitorFactoryFactory({
+      assetName: base.name,
+      interval: config.feeMonitorInterval || feeMonitorInterval || DEFAULT_FEE_MONITOR_INTERVAL,
+    })
+
+    const features = {
+      accountState: true,
+      customTokens,
+      feeMonitor,
+      feesApi: true,
+      isMaxFeeAsset,
+      isTestnet,
+      nfts,
+      noHistory: monitorType === 'no-history',
+      signWithSigner: true,
+      ...(supportsStaking && { staking: {} }),
+    }
+
+    const confirmationNumber = CONFIRMATIONS_NUMBER[asset.name] || 1
+
+    const accountStateClass =
+      CustomAccountState || createEthereumLikeAccountState({ asset: base, assets })
+
+    const createHistoryMonitor = (args) => {
+      let monitor
+      switch (monitorType) {
+        case 'clarity':
+          monitor = new ClarityMonitor({ interval: ms(monitorInterval || '5m'), server, ...args })
+          break
+        case 'no-history':
+          monitor = new EthereumNoHistoryMonitor({
+            interval: ms(monitorInterval || '15s'),
+            server,
+            ...args,
+          })
+          break
+        case 'magnifier':
+          monitor = new EthereumMonitor({ interval: ms(monitorInterval || '15s'), server, ...args })
+          break
+        default:
+          throw new Error(`Monitor type ${monitorType} of evm asset ${asset.name} is unknown`)
+      }
+
+      if (supportsStaking) {
+        const afterTickHook = createEthereumHooks({ assetClientInterface })['after-tick']
+        monitor.addHook('after-tick', afterTickHook)
+      }
+
+      return monitor
+    }
+
+    const defaultAddressPath = 'm/0/0'
+
+    const sendTx = txSendFactory({ assetClientInterface })
+    const api = {
+      addressHasHistory,
+      broadcastTx: (...args) => server.sendRawTransaction(...args),
+      createAccountState: () => accountStateClass,
+      createFeeMonitor,
+      createHistoryMonitor,
+      createToken,
+      createUnsignedTx,
+      defaultAddressPath,
+      features,
+      getBalances,
+      getConfirmationsNumber: () => confirmationNumber,
+      getDefaultAddressPath: () => defaultAddressPath,
+      getFee: customGetFee || getFeeFactory({ gasLimit }),
+      getFeeData: () => feeData,
+      getKeyIdentifier: createGetKeyIdentifier({ bip44, allowMetaMaskCompat }),
+      getSupportedPurposes: () => [44],
+      getTokens,
+      hasFeature: (feature) => !!features[feature], // @deprecated use api.features instead
+      parseUnsignedTx: (unsignedTx, { asset }) => parseUnsignedTx(asset, unsignedTx),
+      sendTx,
+      signTx: ({ unsignedTx, privateKey, signer }) =>
+        signer
+          ? signUnsignedTxWithSigner(unsignedTx, signer)
+          : signUnsignedTx(unsignedTx, privateKey),
+      signUnsignedTx,
+      signHardware: signHardwareFactory({ baseAssetName: asset.name }),
+      signMessage: ({ message, privateKey, signer }) =>
+        signer ? signMessageWithSigner({ message, signer }) : signMessage({ privateKey, message }),
+      ...(supportsStaking && { staking: createStakingApi({ network: asset.name }) }),
+      validateAssetId: address.validate,
+    }
+
+    const fullAsset = {
+      ...asset,
+      ...pick(config, ['accountReserve']),
+      gasLimit,
+      contractGasLimit,
+      bip44,
+      keys,
+      address,
+      api,
+      ...(erc20FuelBuffer && { erc20FuelBuffer }),
+      ...(fuelThreshold && { fuelThreshold: asset.currency.defaultUnit(fuelThreshold) }),
+      getEffectiveGasPrice,
+    }
+    return overrideCallback({ asset: fullAsset })
+  }
+}

package/src/create-token-factory.js

@@ -0,0 +1,72 @@
+import { isPolygonClaimUndelegate, isPolygonDelegate, isPolygonUndelegate } from './staking/matic'
+import { createContract } from '@exodus/ethereum-lib'
+
+import { getBalances } from './get-balances'
+
+import { createStakingApi } from './staking-api'
+
+const defaultTokenFeatures = {
+  isMaxFeeAsset: true,
+}
+
+// Hide on both deposit and withdraw sides
+const smallbalanceTx = (tx) => Math.abs(tx.coinAmount.toBaseNumber()) === 0
+
+const getTxLogFilter = () => (tx) => !smallbalanceTx(tx)
+
+const getPolygonTxLogFilter = () => (tx) =>
+  isPolygonDelegate(tx) ||
+  isPolygonClaimUndelegate(tx) ||
+  isPolygonUndelegate(tx) ||
+  getTxLogFilter()(tx)
+const getPolygonActivityTxs = ({ txs }) =>
+  txs.filter(
+    (tx) =>
+      isPolygonDelegate(tx) ||
+      isPolygonClaimUndelegate(tx) ||
+      isPolygonUndelegate(tx) ||
+      !smallbalanceTx(tx)
+  )
+const getActivityTxs = ({ txs }) => txs.filter((tx) => !smallbalanceTx(tx))
+
+const getCreateBaseToken =
+  (props) =>
+  ({ name, contract, features, ...tokenDef }) => {
+    const tokenSpecificFeatures = name === 'polygon' ? { staking: {} } : {}
+    const tokenSpecificApiFunctions =
+      name === 'polygon' ? { staking: createStakingApi({ network: name }) } : {}
+
+    const tokenFeatures = { ...defaultTokenFeatures, ...features, ...tokenSpecificFeatures }
+    return {
+      ...tokenDef,
+      addresses: contract,
+      assetId: contract.current,
+      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
+    }
+  }
+
+export const createTokenFactory = (props, assets) => {
+  const createBaseToken = getCreateBaseToken(props)
+  const createCustomToken = ({ assetId, assetName, ...rest }) =>
+    createBaseToken({ ...rest, name: assetName, contract: { current: assetId } })
+  const createToken = (tokenDef) =>
+    tokenDef.isBuiltIn ? createBaseToken(tokenDef) : createCustomToken(tokenDef)
+  return {
+    createToken,
+    getTokens: () =>
+      Object.values(assets)
+        .filter((asset) => asset.name !== asset.baseAsset.name) // eslint-disable-next-line unicorn/no-array-callback-reference -- TODO: Fix this the next time the file is edited.
+        .map(createToken),
+  }
+}

package/src/eth-like-util.js

@@ -3,7 +3,7 @@ import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken, ABI } from '@e
 import { memoizeLruCache } from '@exodus/asset-lib'
 import SolidityContract from '@exodus/solidity-contract'
 import { getServerByName, getServer } from './exodus-eth-server'
-import BN from 'bn.js'
+import { fromHexToString } from './number-utils'
 
 export async function isContract(baseAssetName, address) {
   return getServerByName(baseAssetName).isContract(address)
@@ -43,8 +43,7 @@ export async function getBalance({ asset, address }) {
 export async function getBalanceProxied({ asset, address, tag = 'latest' }) {
   if (!isEthereumLikeAsset(asset)) throw new Error(`unsupported asset ${asset.name}`)
   const result = await getServer(asset).getBalanceProxied(address)
-  const hex = result.startsWith('0x') ? result.slice(2) : result
-  return new BN(hex, 'hex').toString()
+  return fromHexToString(result)
 }
 
 // Only ETH-like assets with token support

package/src/exodus-eth-server/api-coin-nodes.js

@@ -1,9 +1,9 @@
-import BN from 'bn.js'
 import { bufferToHex } from '@exodus/ethereumjs-util'
 import SolidityContract from '@exodus/solidity-contract'
 import EventEmitter from 'events'
 import { isEmpty } from 'lodash'
 import { fetch } from '@exodus/fetch'
+import { fromHexToString } from '../number-utils'
 
 export default class ApiCoinNodesServer extends EventEmitter {
   constructor({ uri }) {
@@ -135,8 +135,7 @@ export default class ApiCoinNodesServer extends EventEmitter {
   async balanceOf(address, tokenAddress, tag = 'latest') {
     const request = this.balanceOfRequest(address, tokenAddress, tag)
     const result = await this.sendRequest(request)
-    const hex = result.startsWith('0x') ? result.slice(2) : result
-    const balance = new BN(hex, 'hex').toString()
+    const balance = fromHexToString(result)
     return {
       confirmed: {
         [tokenAddress]: balance,

package/src/exodus-eth-server/api.js

@@ -1,11 +1,11 @@
 import ms from 'ms'
-import BN from 'bn.js'
 import createWebSocket from './ws'
 import fetchival from '@exodus/fetch/experimental/fetchival'
 import { retry } from '@exodus/simple-retry'
 import SolidityContract from '@exodus/solidity-contract'
 import { bufferToHex } from '@exodus/ethereumjs-util'
 import { randomUUID } from '@exodus/crypto/randomUUID'
+import { fromHexToString } from '../number-utils'
 
 const RETRY_DELAYS = ['10s']
 
@@ -88,8 +88,7 @@ export function create(defaultURL, ensAssetName) {
         tag,
       }
       const result = await retry(this.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
-      const hex = result.startsWith('0x') ? result.slice(2) : result
-      const balance = new BN(hex, 'hex').toString()
+      const balance = fromHexToString(result)
       return {
         confirmed: {
           [tokenAddress]: balance,

package/src/exodus-eth-server/clarity.js

@@ -1,8 +1,8 @@
-import BN from 'bn.js'
 import { bufferToHex } from '@exodus/ethereumjs-util'
 import SolidityContract from '@exodus/solidity-contract'
 import EventEmitter from 'events'
 import io from 'socket.io-client'
+import { fromHexToString } from '../number-utils'
 
 export default class ClarityServer extends EventEmitter {
   constructor({ baseAssetName, uri }) {
@@ -51,7 +51,10 @@ export default class ClarityServer extends EventEmitter {
   }
 
   createSocket(namespace) {
-    return io(`${this.uri}${namespace}`, { transports: ['websocket', 'polling'] })
+    return io(`${this.uri}${namespace}`, {
+      transports: ['websocket', 'polling'],
+      extraHeaders: { 'User-Agent': 'exodus' },
+    })
   }
 
   disconnectTransactions(address) {
@@ -296,8 +299,7 @@ export default class ClarityServer extends EventEmitter {
   async balanceOf(address, tokenAddress, tag = 'latest') {
     const request = this.balanceOfRequest(address, tokenAddress, tag)
     const result = await this.sendRequest(request)
-    const hex = result.startsWith('0x') ? result.slice(2) : result
-    const balance = new BN(hex, 'hex').toString()
+    const balance = fromHexToString(result)
     return {
       confirmed: {
         [tokenAddress]: balance,

package/src/get-balances.js

@@ -1,4 +1,4 @@
-import { getEthereumBalances, isRpcBalanceAsset } from '@exodus/ethereum-lib'
+import { isRpcBalanceAsset } from '@exodus/ethereum-lib'
 
 import { get } from 'lodash'
 
@@ -30,22 +30,27 @@ const getBalanceFromTxLog = ({ txLog, asset }) => {
   return txLog.size > 0 ? txLog.getMutations().slice(-1)[0].balance : asset.currency.ZERO
 }
 
-const getBalance = ({ asset, accountState, txLog }) => {
+const getStaked = ({ accountState, asset }) => {
+  return get(accountState, ['staking', asset.name, 'delegatedBalance']) || asset.currency.ZERO
+}
+
+const getUnstaking = ({ accountState, asset }) => {
+  return get(accountState, ['staking', asset.name, 'undelegatedBalance']) || asset.currency.ZERO
+}
+
+const getUnstaked = ({ accountState, asset }) => {
+  return (
+    get(accountState, ['staking', asset.name, 'unclaimedUndelegatedBalance']) || asset.currency.ZERO
+  )
+}
+
+function getBasicSpendable({ asset, accountState, txLog }) {
   const balance = isRpcBalanceAsset(asset)
     ? getBalanceFromAccountState({ asset, accountState })
     : getBalanceFromTxLog({ txLog, asset })
 
   const shouldFixBalance = isRpcBalanceAsset(asset)
 
-  if (['ethereum', 'ethereumgoerli', 'ethereumholesky', 'ethereumsepolia'].includes(asset.name)) {
-    const { balance: ethereumBalance } = getEthereumBalances({
-      asset,
-      liquidBalance: balance,
-      accountState,
-    })
-    return ethereumBalance
-  }
-
   return shouldFixBalance ? fixBalance({ txLog, balance }) : balance
 }
 
@@ -58,6 +63,23 @@ const getBalance = ({ asset, accountState, txLog }) => {
  * @returns {{balance}|null} an object with the balance or null if the balance is unknown
  */
 export const getBalances = ({ asset, txLog, accountState }) => {
-  const balance = getBalance({ asset, accountState, txLog })
-  return { balance }
+  const spendable = getBasicSpendable({ asset, accountState, txLog })
+
+  const staked = getStaked({ asset, accountState })
+  const unstaking = getUnstaking({ asset, accountState })
+  const unstaked = getUnstaked({ asset, accountState })
+
+  const total = spendable.add(staked).add(unstaking).add(unstaked)
+
+  return {
+    // new
+    spendable,
+    total,
+    staked,
+    unstaking,
+    unstaked,
+    // legacy
+    balance: total,
+    spendableBalance: spendable,
+  }
 }

package/src/get-fee.js

@@ -0,0 +1,97 @@
+import { calculateBumpedGasPrice, calculateExtraEth, isEthereumLike } from '@exodus/ethereum-lib'
+
+// Move to meta?
+const taxes = {
+  paxgold: 0.0002,
+}
+
+const getGasPriceMultiplier = ({ asset, feeData, isExchange, isSendAll }) => {
+  // 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 (!feeData.rbfEnabled) return 1
+
+  return feeData.gasPriceEconomicalRate
+}
+
+const getExtraFeeData = ({ asset, amount }) => {
+  const tax = taxes[asset.name]
+  if (!amount || !tax || amount.isZero) {
+    return {}
+  }
+
+  const extraFee = amount.mul(tax)
+  return {
+    type: 'tax',
+    tax,
+    extraFee,
+  }
+}
+
+export const getFeeFactory =
+  ({ gasLimit: defaultGasLimit }) =>
+  ({
+    asset,
+    feeData,
+    customFee,
+    gasLimit = defaultGasLimit,
+    isExchange,
+    isSendAll,
+    amount,
+    calculateEffectiveFee, // BE
+    customFee: customGasPrice, // BE
+  }) => {
+    const { gasPrice, eip1559Enabled, baseFeePerGas, tipGasPrice } = feeData
+    const gasPriceMultiplier = getGasPriceMultiplier({
+      asset,
+      feeData,
+      isExchange,
+      isSendAll,
+    })
+
+    const extraFeeData = getExtraFeeData({ asset, amount })
+    if (calculateEffectiveFee && eip1559Enabled) {
+      const maxFeePerGas = customGasPrice || 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
+
+      return { fee: effectiveGasPrice.mul(gasLimit), extraFeeData }
+    }
+
+    const fee = (customFee || gasPrice.mul(gasPriceMultiplier)).mul(gasLimit || asset.gasLimit)
+    return { fee, extraFeeData }
+  }
+
+// Used in BE
+export const getEffectiveGasPrice = ({ feeData }) => {
+  const { baseFeePerGas, tipGasPrice, gasPrice: maxFeePerGas, eip1559Enabled } = feeData
+
+  if (!eip1559Enabled) {
+    return maxFeePerGas
+  }
+
+  const gasPrice = baseFeePerGas.add(tipGasPrice)
+  return gasPrice.lt(maxFeePerGas) ? gasPrice : maxFeePerGas
+}
+
+// Used in Mobile
+export const getExtraFeeForBump = ({ tx, feeData, balance, unconfirmedBalance }) => {
+  if (!balance || !unconfirmedBalance) return null
+  const { gasPrice: currentGasPrice, eip1559Enabled } = feeData
+  const { bumpedGasPrice } = calculateBumpedGasPrice({
+    baseAsset: 'ethereum',
+    tx,
+    currentGasPrice,
+    eip1559Enabled,
+  })
+  return calculateExtraEth({
+    fee: bumpedGasPrice.mul(tx.data.gasLimit),
+    balance: balance.sub(unconfirmedBalance),
+  })
+}

package/src/hooks/index.js

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

package/src/hooks/monitor.js

@@ -0,0 +1,88 @@
+import { getEthereumStakingInfo, getPolygonStakingInfo } from '../staking'
+import { isEmpty } from 'lodash'
+
+import processTxLog from '../tx-log-staking-processor'
+
+export const createEthereumHooks = ({ assetClientInterface }) => {
+  const afterTickHook = async ({ walletAccount }) => {
+    // args passed from monitor tick method ({ monitor, error })
+    const { ethereum, polygon } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: 'ethereum',
+    })
+
+    const assetName = ethereum.name
+
+    const userAddress = await assetClientInterface.getReceiveAddress({
+      assetName,
+      walletAccount,
+      useCache: true,
+    })
+
+    const ethereumStakingInfo = await getEthereumStakingInfo({
+      address: userAddress.toString(),
+      asset: ethereum,
+    })
+
+    const polygonStakingInfo = await getPolygonStakingInfo({
+      address: userAddress.toString(),
+      asset: polygon,
+    })
+
+    const stakingInfo = {
+      staking: {
+        ethereum: ethereumStakingInfo,
+        polygon: polygonStakingInfo,
+      },
+    }
+
+    const batch = assetClientInterface.createOperationsBatch()
+    assetClientInterface.updateAccountStateBatch({
+      assetName: ethereum.name,
+      walletAccount,
+      newData: stakingInfo,
+      batch,
+    })
+
+    const processTxLogsPromises = []
+
+    const holeskyAssets = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: 'ethereumholesky',
+    })
+
+    if (!isEmpty(holeskyAssets)) {
+      const { ethereumholesky } = holeskyAssets
+      // eslint-disable-next-line no-console
+      console.log('ethereum-hooks updating holesky state')
+
+      const ethereumHoleskyInfo = await getEthereumStakingInfo({
+        address: userAddress.toString(),
+        asset: ethereumholesky,
+      })
+
+      assetClientInterface.updateAccountStateBatch({
+        assetName: ethereumholesky.name,
+        walletAccount,
+        newData: {
+          staking: {
+            ethereumholesky: ethereumHoleskyInfo,
+          },
+        },
+        batch,
+      })
+      processTxLogsPromises.push(
+        processTxLog({ asset: ethereumholesky, assetClientInterface, walletAccount, batch })
+      )
+    }
+
+    processTxLogsPromises.push(
+      processTxLog({ asset: polygon, assetClientInterface, walletAccount, batch }),
+      processTxLog({ asset: ethereum, assetClientInterface, walletAccount, batch })
+    )
+    await Promise.all(processTxLogsPromises)
+    await assetClientInterface.executeOperationsBatch(batch)
+  }
+
+  return {
+    'after-tick': afterTickHook,
+  }
+}