@exodus/ethereum-api 8.45.6 → 8.46.0

package/CHANGELOG.md

@@ -3,6 +3,16 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.46.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.45.6...@exodus/ethereum-api@8.46.0) (2025-08-21)
+
+
+### Features
+
+
+* feat: implement clarity websocket gateway client (#5623)
+
+
+
 ## [8.45.6](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.45.5...@exodus/ethereum-api@8.45.6) (2025-08-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.45.6",
+  "version": "8.46.0",
   "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",
@@ -39,6 +39,7 @@
     "@exodus/web3-ethereum-utils": "^4.2.1",
     "bn.js": "^5.2.1",
     "delay": "^4.0.1",
+    "eventemitter3": "^4.0.7",
     "events": "^1.1.1",
     "idna-uts46-hx": "^2.3.1",
     "lodash": "^4.17.15",
@@ -63,5 +64,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "41fe883d14291bfb6b73b37b617ce2f7fa914edb"
+  "gitHead": "9d7bd1606fa42f6e05c68e0396d5aed7f7ea8852"
 }

package/src/create-asset-utils.js

@@ -4,6 +4,7 @@ import ms from 'ms'
 import { createEvmServer, ValidMonitorTypes } from './exodus-eth-server/index.js'
 import { createEthereumHooks } from './hooks/index.js'
 import { ClarityMonitor } from './tx-log/clarity-monitor.js'
+import { ClarityMonitorV2 } from './tx-log/clarity-monitor-v2.js'
 import { EthereumMonitor } from './tx-log/ethereum-monitor.js'
 import { EthereumNoHistoryMonitor } from './tx-log/ethereum-no-history-monitor.js'
 import { resolveNonce } from './tx-send/nonce-utils.js'
@@ -128,6 +129,15 @@ export const createHistoryMonitorFactory = ({
           ...args,
         })
         break
+      case 'clarity-v3':
+        monitor = new ClarityMonitorV2({
+          assetClientInterface,
+          interval: ms(monitorInterval || '5m'),
+          server,
+          rpcBalanceAssetNames,
+          ...args,
+        })
+        break
       case 'no-history':
         monitor = new EthereumNoHistoryMonitor({
           assetClientInterface,

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

@@ -13,7 +13,7 @@ import ApiCoinNodesServer from './api-coin-nodes.js'
 import ClarityServer from './clarity.js'
 import ClarityServerV2 from './clarity-v2.js'
 
-export const ValidMonitorTypes = ['no-history', 'clarity', 'clarity-v2', 'magnifier']
+export const ValidMonitorTypes = ['no-history', 'clarity', 'clarity-v2', 'clarity-v3', 'magnifier']
 
 export function createEvmServer({ assetName, serverUrl, monitorType }) {
   assert(assetName, 'assetName is required')
@@ -25,6 +25,7 @@ export function createEvmServer({ assetName, serverUrl, monitorType }) {
     case 'clarity':
       return new ClarityServer({ baseAssetName: assetName, uri: serverUrl })
     case 'clarity-v2':
+    case 'clarity-v3':
       return new ClarityServerV2({ baseAssetName: assetName, uri: serverUrl })
     case 'magnifier':
       return create(serverUrl, assetName)

package/src/exodus-eth-server/ws-gateway.js

@@ -0,0 +1,267 @@
+import { createConsoleLogger } from '@exodus/asset-lib'
+import WebSocket from '@exodus/fetch/websocket'
+import EventEmitter from 'eventemitter3'
+import assert from 'minimalistic-assert'
+
+const createSubscriptionName = (network) => {
+  return `v1/transactions/${network}`
+}
+
+const createSubscriptionKey = ({ subscriptionName, address }) => {
+  return `${subscriptionName}|${address}`
+}
+
+const parseSubscriptionKey = (subscriptionKey) => {
+  const [subscriptionName, address] = subscriptionKey.split('|')
+
+  return {
+    subscriptionName,
+    subscriptionAddress: address,
+  }
+}
+
+/**
+ * @typedef subscribeWalletAddresses
+ * @property {string} network
+ * @property {string} address
+ */
+
+class WsGateway extends EventEmitter {
+  #socket = null
+  // Dedup subscriptions to reduce workload on server and resubscribe after closing
+  #subscriptions = new Set()
+  #reconnectionTimeoutId = null
+  #defaultUri = 'wss://ws-gateway-clarity.a.exodus.io'
+  #uri = null
+  #logger = createConsoleLogger(`@exodus/ws-gateway`)
+
+  _handlers = {
+    message: ({ target, data }) => {
+      if (target !== this.#socket) return
+      const msg = JSON.parse(data)
+
+      if (Array.isArray(msg)) {
+        for (const item of msg) {
+          this.#handleMessage(item)
+        }
+
+        return
+      }
+
+      this.#handleMessage(msg)
+    },
+    close: ({ target, code, reason }) => {
+      if (target !== this.#socket) return
+      this.#reconnect({ code, reason })
+    },
+    open: ({ target }) => {
+      if (target !== this.#socket) return
+      this.emit('opened')
+    },
+    error: ({ target }) => {
+      if (target !== this.#socket) return
+      this.#reconnect({ code: 0, reason: 'Error' })
+    },
+  }
+
+  getSocket() {
+    return this.#socket
+  }
+
+  getSubscriptions() {
+    return this.#subscriptions
+  }
+
+  setServer(uri) {
+    this.#uri = uri || this.#uri || this.#defaultUri
+  }
+
+  start() {
+    if (this.#socket) {
+      return
+    }
+
+    this.#socket = new WebSocket(this.#uri)
+
+    this.#socket.addEventListener('message', this._handlers.message)
+    this.#socket.addEventListener('close', this._handlers.close)
+    this.#socket.addEventListener('open', this._handlers.open)
+    this.#socket.addEventListener('error', this._handlers.error)
+  }
+
+  #reconnect({ code, reason } = {}) {
+    this.#logger.warn(`Reconnect. Code ${code}, ${reason || 'Empty reason'}`)
+
+    this.#clearSocketListeners()
+
+    if (this.#socket.readyState === WebSocket.CLOSED) this.#socket = null
+    clearTimeout(this.#reconnectionTimeoutId)
+    this.#subscriptions.clear()
+
+    this.#reconnectionTimeoutId = setTimeout(() => {
+      this.start()
+      clearTimeout(this.#reconnectionTimeoutId)
+    }, 2500)
+  }
+
+  unsubscribeWalletAddresses({ network, addresses = [] } = {}) {
+    assert(network, '"network" is required')
+
+    const unsubscribeName = createSubscriptionName(network)
+
+    const payload = []
+
+    const addressesSet = new Set(addresses)
+
+    for (const subscriptionKey of this.#subscriptions) {
+      const { subscriptionName, subscriptionAddress } = parseSubscriptionKey(subscriptionKey)
+      if (subscriptionName !== unsubscribeName) continue
+
+      // Unsubscribe whole network
+      if (addressesSet.size === 0) {
+        if (!payload.some((item) => item.subscription === subscriptionName)) {
+          payload.push({
+            subscription: subscriptionName,
+          })
+        }
+
+        this.#subscriptions.delete(subscriptionKey)
+        continue
+      }
+
+      if (addressesSet.has(subscriptionAddress)) {
+        payload.push({
+          subscription: subscriptionName,
+          entityId: subscriptionAddress,
+        })
+        this.#subscriptions.delete(subscriptionKey)
+      }
+    }
+
+    if (payload.length === 0) {
+      return
+    }
+
+    this.#sendMessage({
+      eventName: 'unsubscribe',
+      payload,
+    })
+  }
+
+  /**
+   * @param {Array<subscribeWalletAddresses>} subscriptions
+   */
+  subscribeWalletAddresses({ network, addresses }) {
+    const payload = []
+
+    for (const address of addresses) {
+      const subscriptionName = createSubscriptionName(network)
+      const subscriptionKey = createSubscriptionKey({ subscriptionName, address })
+
+      if (this.#subscriptions.has(subscriptionKey)) {
+        continue
+      }
+
+      payload.push({
+        subscription: subscriptionName,
+        entityId: address,
+      })
+    }
+
+    if (payload.length === 0) {
+      return
+    }
+
+    this.#sendMessage({
+      eventName: 'subscribe',
+      payload,
+    })
+  }
+
+  #sendMessage(message) {
+    if (this.#socket.readyState !== WebSocket.OPEN) {
+      return
+    }
+
+    this.#socket.send(JSON.stringify(message))
+  }
+
+  #handleMessage(message) {
+    switch (message.type) {
+      case 'new_transactions': {
+        const { subscription, entityId, payload } = message
+        const network = subscription.split('/')[2]
+
+        for (const transaction of payload.transactions) {
+          this.emit(`${network}:new_transaction`, {
+            address: entityId,
+            transaction,
+            cursor: payload.cursor,
+          })
+        }
+
+        break
+      }
+
+      case 'connection_ack': {
+        this.emit('connected', message)
+        break
+      }
+
+      case 'subscribe_ack': {
+        const { subscription, entityId } = message
+
+        const subscriptionKey = createSubscriptionKey({
+          subscriptionName: subscription,
+          address: entityId,
+        })
+        this.#subscriptions.add(subscriptionKey)
+
+        this.emit('subscribed', message)
+        break
+      }
+
+      case 'error': {
+        this.#logger.error('Error from server', message)
+        this.emit('error', message)
+        break
+      }
+
+      default: {
+        break
+      }
+    }
+  }
+
+  #clearSocketListeners() {
+    if (!this.#socket) return
+
+    this.#socket.removeEventListener('message', this._handlers.message)
+    this.#socket.removeEventListener('close', this._handlers.close)
+    this.#socket.removeEventListener('open', this._handlers.open)
+    this.#socket.removeEventListener('error', this._handlers.error)
+  }
+
+  dispose(network, addresses) {
+    this.unsubscribeWalletAddresses({ network, addresses })
+
+    if (this.#subscriptions.size > 0) {
+      return
+    }
+
+    this.#clearSocketListeners()
+
+    clearTimeout(this.#reconnectionTimeoutId)
+
+    if (this.#socket && [WebSocket.OPEN, WebSocket.CONNECTING].includes(this.#socket.readyState)) {
+      this.#socket.close()
+    }
+
+    this.#socket = null
+  }
+}
+
+const wsGateway = new WsGateway()
+const createWsGateway = () => wsGateway
+
+export { createWsGateway, WsGateway }

package/src/tx-log/clarity-monitor-v2.js

@@ -0,0 +1,467 @@
+import { BaseMonitor } from '@exodus/asset-lib'
+import { getAssetAddresses } from '@exodus/ethereum-lib'
+import lodash from 'lodash'
+
+import { createWsGateway } from '../exodus-eth-server/ws-gateway.js'
+import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
+import { fromHexToString } from '../number-utils.js'
+import { filterEffects, getLogItemsFromServerTx } from './clarity-utils/index.js'
+import {
+  checkPendingTransactions,
+  excludeUnchangedTokenBalances,
+  getAllLogItemsByAsset,
+  getDeriveDataNeededForTick,
+  getDeriveTransactionsToCheck,
+} from './monitor-utils/index.js'
+
+const { isEmpty } = lodash
+
+export class ClarityMonitorV2 extends BaseMonitor {
+  #wsClient = null
+  #walletAccountByAddress = new Map()
+  #walletAccountInfo = new Map()
+  #rpcBalanceAssetNames = []
+  constructor({
+    server,
+    wsGatewayClient = createWsGateway(),
+    rpcBalanceAssetNames,
+    config,
+    ...args
+  } = {}) {
+    super(args)
+    this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
+    this.server = server
+    this.#wsClient = wsGatewayClient
+    this.#rpcBalanceAssetNames = rpcBalanceAssetNames
+    this.getAllLogItemsByAsset = getAllLogItemsByAsset
+    this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
+    this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
+      getTxLog: (...args) => this.aci.getTxLog(...args),
+    })
+
+    this.addHook('before-start', (...args) => this.beforeStart(...args))
+    this.addHook('after-stop', (...args) => this.afterStop(...args))
+  }
+
+  setServer(config) {
+    const uri = config?.server || this.server.defaultUri
+
+    this.#wsClient.setServer(config.wsGatewayUrl?.v1)
+
+    this.#wsClient.on('connected', () => this.subscribeAllWalletAccounts())
+    this.#wsClient.start()
+
+    if (uri === this.server.uri) {
+      return
+    }
+
+    this.server.setURI(uri)
+    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
+      this.server.connectFee()
+    }
+  }
+
+  async deriveData({ assetName, walletAccount, tokens }) {
+    const { ourWalletAddress, currentAccountState } = await this.deriveDataNeededForTick({
+      assetName,
+      walletAccount,
+    })
+    const transactionsToCheck = await this.deriveTransactionsToCheck({
+      assetName,
+      walletAccount,
+      tokens,
+      ourWalletAddress,
+    })
+
+    return {
+      ourWalletAddress,
+      currentAccountState,
+      ...transactionsToCheck,
+    }
+  }
+
+  // eslint-disable-next-line no-undef
+  async checkPendingTransactions(params) {
+    const { pendingTransactionsToCheck, pendingTransactionsGroupedByAddressAndNonce } =
+      checkPendingTransactions(params)
+    const txsToRemove = []
+    const { walletAccount } = params
+
+    const updateTx = (tx, asset, { error, remove }) => {
+      if (remove) {
+        txsToRemove.push({ tx, assetSource: { asset, walletAccount } })
+      } else {
+        params.logItemsByAsset[asset].push({
+          ...tx,
+          dropped: true,
+          error,
+        })
+      }
+
+      // in case this is an ETH fee tx that has associated ERC20 send txs
+      const promises = tx.tokens.map(async (assetName) => {
+        const tokenTxSet = await this.aci.getTxLog({ assetName, walletAccount })
+        if (remove) {
+          txsToRemove.push({
+            tx: tokenTxSet.get(tx.txId),
+            assetSource: { asset: assetName, walletAccount },
+          })
+        } else if (tokenTxSet && tokenTxSet.has(tx.txId)) {
+          params.logItemsByAsset[assetName].push({
+            ...tokenTxSet.get(tx.txId),
+            error,
+            dropped: true,
+          })
+        }
+      })
+      return Promise.all(promises)
+    }
+
+    for (const { tx, assetName, replaced = false } of Object.values(
+      pendingTransactionsGroupedByAddressAndNonce
+    )) {
+      if (replaced) {
+        await updateTx(tx, assetName, { remove: true })
+        delete pendingTransactionsToCheck[tx.txId]
+      }
+    }
+
+    for (const { tx, assetName } of Object.values(pendingTransactionsToCheck)) {
+      if (params.refresh) await updateTx(tx, assetName, { remove: true })
+      else await updateTx(tx, assetName, { error: 'Dropped' })
+    }
+
+    return { txsToRemove }
+  }
+
+  async tick({ walletAccount, refresh }) {
+    await this.subscribeWalletAddresses(walletAccount)
+
+    const walletAccountInfo = this.#walletAccountInfo.get(walletAccount)
+
+    if (!walletAccountInfo) {
+      return this.logger.warn('walletAccountInfo is empty', { walletAccount })
+    }
+
+    const { derivedData, tokensByAddress, assets, tokens, assetName } = walletAccountInfo
+
+    const response = await this.getHistoryFromServer({ walletAccount, derivedData, refresh })
+    const allTxs = [...response.transactions.pending, ...response.transactions.confirmed]
+    const cursor = response.cursor
+
+    await this.processAndFillTransactionsToState({
+      allTxs,
+      derivedData,
+      tokensByAddress,
+      assets,
+      tokens,
+      assetName,
+      walletAccount,
+      refresh,
+      cursor,
+    })
+  }
+
+  async processAndFillTransactionsToState({
+    allTxs,
+    derivedData,
+    tokensByAddress,
+    assets,
+    tokens,
+    assetName,
+    walletAccount,
+    refresh,
+    cursor,
+  }) {
+    const hasNewTxs = allTxs.length > 0
+
+    const logItemsByAsset = this.getAllLogItemsByAsset({
+      getLogItemsFromServerTx,
+      ourWalletAddress: derivedData.ourWalletAddress,
+      allTransactionsFromServer: allTxs,
+      asset: this.asset,
+      tokensByAddress,
+      assets,
+    })
+
+    const { txsToRemove } = await this.checkPendingTransactions({
+      txlist: allTxs,
+      walletAccount,
+      refresh,
+      logItemsByAsset,
+      asset: this.asset,
+      ...derivedData,
+    })
+
+    const accountState = await this.getNewAccountState({
+      tokens,
+      currentTokenBalances: derivedData.currentAccountState?.tokenBalances,
+      ourWalletAddress: derivedData.ourWalletAddress,
+    })
+
+    const batch = this.aci.createOperationsBatch()
+
+    this.aci.removeTxLogBatch({
+      assetName,
+      walletAccount,
+      txs: txsToRemove,
+      batch,
+    })
+
+    for (const [assetName, txs] of Object.entries(logItemsByAsset)) {
+      this.aci.updateTxLogAndNotifyBatch({
+        assetName,
+        walletAccount,
+        txs,
+        refresh,
+        batch,
+      })
+    }
+
+    const newData = { ...accountState }
+
+    if (cursor) {
+      newData.clarityCursor = cursor
+    }
+
+    this.aci.updateAccountStateBatch({
+      assetName,
+      walletAccount,
+      accountState,
+      newData,
+      batch,
+    })
+
+    await this.aci.executeOperationsBatch(batch)
+
+    if (refresh || hasNewTxs) {
+      const unknownTokenAddresses = this.getUnknownTokenAddresses({
+        transactions: allTxs,
+        tokensByAddress,
+      })
+      if (unknownTokenAddresses.length > 0) {
+        this.emit('unknown-tokens', unknownTokenAddresses)
+      }
+    }
+  }
+
+  async addSingleTx({ tx, address, cursor }) {
+    const walletAccounts = this.#walletAccountByAddress.get(address)
+
+    if (!walletAccounts || walletAccounts.length === 0) {
+      return
+    }
+
+    for (const walletAccount of walletAccounts) {
+      const walletAccountInfo = this.#walletAccountInfo.get(walletAccount)
+
+      if (!walletAccountInfo) {
+        continue
+      }
+
+      const { derivedData, tokensByAddress, assets, tokens, assetName } = walletAccountInfo
+
+      await this.processAndFillTransactionsToState({
+        allTxs: [tx],
+        derivedData,
+        tokensByAddress,
+        assets,
+        tokens,
+        assetName,
+        walletAccount,
+        refresh: false,
+        cursor,
+      })
+    }
+  }
+
+  async getNewAccountState({ tokens, currentTokenBalances, ourWalletAddress }) {
+    const asset = this.asset
+    const newAccountState = Object.create(null)
+    const balances = await this.getBalances({ tokens, ourWalletAddress })
+    if (this.#rpcBalanceAssetNames.includes(asset.name)) {
+      const balance = balances[asset.name]
+      newAccountState.balance = asset.currency.baseUnit(balance)
+    }
+
+    const tokenBalancePairs = Object.entries(balances).filter((entry) => entry[0] !== asset.name)
+    const tokenBalanceEntries = tokenBalancePairs
+      .map((pair) => {
+        const token = tokens.find((token) => token.name === pair[0])
+        const value = token.currency.baseUnit(pair[1] || 0)
+        return [token.name, value]
+      })
+      .filter(Boolean)
+
+    const tokenBalances = excludeUnchangedTokenBalances(currentTokenBalances, tokenBalanceEntries)
+    if (!isEmpty(tokenBalances)) newAccountState.tokenBalances = tokenBalances
+    return newAccountState
+  }
+
+  async getReceiveAddressesByWalletAccount() {
+    const walletAccounts = await this.aci.getWalletAccounts({ assetName: this.asset.name })
+    const addressesByAccount = Object.create(null)
+    for (const walletAccount of walletAccounts) {
+      addressesByAccount[walletAccount] = await this.aci.getReceiveAddresses({
+        assetName: this.asset.name,
+        walletAccount,
+        useCache: true,
+      })
+    }
+
+    return addressesByAccount
+  }
+
+  async fillAssetsTokensAndData({ walletAccount }) {
+    const assetName = this.asset.name
+    const assets = await this.aci.getAssetsForNetwork({ baseAssetName: assetName })
+    const tokens = Object.values(assets).filter((asset) => assetName !== asset.name)
+
+    const tokensByAddress = tokens.reduce((map, token) => {
+      const addresses = getAssetAddresses(token)
+      for (const address of addresses) map.set(address.toLowerCase(), token)
+      return map
+    }, new Map())
+
+    const derivedData = await this.deriveData({ assetName, walletAccount, tokens })
+
+    this.#walletAccountInfo.set(walletAccount, {
+      assets,
+      tokens,
+      tokensByAddress,
+      derivedData,
+      assetName,
+    })
+  }
+
+  async subscribeAllWalletAccounts() {
+    const addressesByWalletAccount = await this.getReceiveAddressesByWalletAccount()
+    const entriesAddressesByWalletAccount = Object.entries(addressesByWalletAccount)
+
+    for (const [walletAccount] of entriesAddressesByWalletAccount) {
+      await this.subscribeWalletAddresses(walletAccount)
+    }
+  }
+
+  async subscribeWalletAddresses(walletAccount) {
+    const addressesByWalletAccount = await this.aci.getReceiveAddresses({
+      assetName: this.asset.name,
+      walletAccount,
+      useCache: true,
+    })
+
+    const address = addressesByWalletAccount[0].toLowerCase() // Only check m/0/0
+    await this.fillAssetsTokensAndData({ walletAccount })
+
+    if (!this.#walletAccountByAddress.has(address)) {
+      this.#walletAccountByAddress.set(address, [])
+    }
+
+    const walletAccounts = this.#walletAccountByAddress.get(address)
+
+    if (!walletAccounts.includes(walletAccount)) {
+      walletAccounts.push(walletAccount)
+      this.#walletAccountByAddress.set(address, walletAccounts)
+    }
+
+    this.server.connectTransactions({ walletAccount, address })
+
+    this.#wsClient.subscribeWalletAddresses({
+      network: this.asset.name,
+      addresses: [address],
+    })
+  }
+
+  async getBalances({ tokens, ourWalletAddress }) {
+    const batch = Object.create(null)
+    if (this.#rpcBalanceAssetNames.includes(this.asset.name)) {
+      const request = this.server.getBalanceRequest(ourWalletAddress)
+      batch[this.asset.name] = request
+    }
+
+    for (const token of tokens) {
+      if (this.#rpcBalanceAssetNames.includes(token.name) && token.contract.address) {
+        const request = this.server.balanceOfRequest(ourWalletAddress, token.contract.address)
+        batch[token.name] = request
+      }
+    }
+
+    const pairs = Object.entries(batch)
+    if (pairs.length === 0) {
+      return {}
+    }
+
+    const requests = pairs.map((pair) => pair[1])
+    const responses = await this.server.sendBatchRequest(requests)
+    const entries = pairs.map((pair, idx) => {
+      const balanceHex = responses[idx]
+      const name = pair[0]
+      const balance = fromHexToString(balanceHex)
+      return [name, balance]
+    })
+    return Object.fromEntries(entries)
+  }
+
+  getUnknownTokenAddresses({ transactions, tokensByAddress }) {
+    const set = transactions.reduce((acc, txn) => {
+      const transfers = filterEffects(txn.effects, 'erc20') || []
+      transfers.forEach((transfer) => {
+        const addr = transfer.address.toLowerCase()
+        if (!tokensByAddress.has(addr)) {
+          acc.add(addr)
+        }
+      })
+      return acc
+    }, new Set())
+    return [...set]
+  }
+
+  // NOTE: Here, fetchedGasPrices is the result of a call to `ClarityMonitor.getFee()`.
+  async updateGasPrice(fetchedGasPrices) {
+    try {
+      await executeEthLikeFeeMonitorUpdate({
+        assetClientInterface: this.aci,
+        feeAsset: this.asset,
+        fetchedGasPrices,
+      })
+    } catch (e) {
+      this.logger.warn('error updating gasPrice', e)
+    }
+  }
+
+  async onFeeUpdated(fee) {
+    return this.updateGasPrice(fee)
+  }
+
+  async beforeStart() {
+    this.listenToServerEvents()
+    if (this.config.GAS_PRICE_FROM_WEBSOCKET) {
+      this.server.connectFee()
+    }
+  }
+
+  async afterStop() {
+    this.server.dispose()
+    this.#wsClient.dispose(this.asset.name)
+  }
+
+  async getHistoryFromServer({ walletAccount, derivedData, refresh }) {
+    const address = derivedData.ourWalletAddress
+    const currentCursor = derivedData.currentAccountState?.clarityCursor
+    const cursor = currentCursor && !refresh ? currentCursor : null
+    return this.server.getAllTransactions({ walletAccount, address, cursor })
+  }
+
+  listenToServerEvents() {
+    this.server.on('feeUpdated', (...args) => this.onFeeUpdated(...args))
+    this.#wsClient.on(
+      `${this.asset.name}:new_transaction`,
+      async ({ transaction, address, cursor }) =>
+        this.addSingleTx({
+          tx: transaction,
+          address,
+          cursor,
+        })
+    )
+  }
+}