@exodus/ethereum-api 9.0.3 → 10.1.0

package/src/staking/evm/staking-errors.js

@@ -0,0 +1,37 @@
+export const createRejectionError = ({ operation, check }) => {
+  const error = new Error(`Cannot ${operation}: ${check.reasonCode}`)
+  error.name = 'StakingRejectionError'
+  error.reasonCode = check.reasonCode
+  if (check.shortfall) {
+    error.shortfall = check.shortfall
+    error.shortfallAssetName = check.shortfallAssetName
+  }
+
+  return error
+}
+
+export const createSubmitError = ({ error, txIds, failedIndex }) => {
+  const submitError = new Error(error.message, { cause: error })
+  submitError.name = 'StakingSubmitError'
+  submitError.txIds = txIds
+  submitError.failedIndex = failedIndex
+  return submitError
+}
+
+export const fail = (reasonCode, shortfall, shortfallAssetName) => ({
+  ok: false,
+  reasonCode,
+  ...(shortfall && { shortfall, shortfallAssetName }),
+})
+
+export const pass = (warnings = []) => (warnings.length > 0 ? { ok: true, warnings } : { ok: true })
+
+export const sumOperationFees = ({ estimateOperationFee, operations }) => {
+  if (!estimateOperationFee) return
+  const fees = operations.map(estimateOperationFee)
+  if (fees.some((fee) => !fee)) return
+  return fees.reduce((total, fee) => total.add(fee))
+}
+
+export const warnIfBelow = ({ balance, required, warning }) =>
+  pass(balance && required && balance.lt(required) ? [warning] : [])

package/src/staking/evm/staking-txs.js

@@ -0,0 +1,107 @@
+import assert from 'minimalistic-assert'
+
+export const STAKING_TX_MODE = Object.freeze({ single: 'single', bundle: 'bundle' })
+
+const createSingleTx = async ({ asset, walletAccount, step, gasPrice, tipGasPrice, feeData }) => {
+  const createdTx = await asset.baseAsset.api.createTx({
+    asset,
+    walletAccount,
+    address: step.to,
+    amount: step.amount || asset.currency.ZERO,
+    txInput: step.txInput,
+    gasPrice,
+    gasLimit: step.gasLimit,
+    tipGasPrice,
+    feeData,
+  })
+  return [createdTx]
+}
+
+const createBundleTxs = async ({
+  asset,
+  walletAccount,
+  fromAddress,
+  steps,
+  gasPrice,
+  tipGasPrice,
+}) => {
+  const baseNonce = await asset.baseAsset.getNonce({ asset, fromAddress, walletAccount })
+
+  return Promise.all(
+    steps.map((step, index) =>
+      asset.baseAsset.api.createTx({
+        asset,
+        walletAccount,
+        fromAddress,
+        amount: step.amount || asset.currency.ZERO,
+        tipGasPrice,
+        gasPrice,
+        toAddress: step.to,
+        txInput: step.txInput,
+        gasLimit: step.gasLimit,
+        nonce: baseNonce + index,
+      })
+    )
+  )
+}
+
+export async function createStakingTxs({
+  asset,
+  walletAccount,
+  fromAddress,
+  steps,
+  mode,
+  gasPrice,
+  tipGasPrice,
+  feeData,
+}) {
+  assert(steps.length > 0, 'staking txs require at least one step')
+  assert(
+    steps.every(({ amount }) => !amount || amount.unitType.equals(asset.currency)),
+    `staking tx amounts must be in ${asset.name}, the asset sending the txs`
+  )
+
+  switch (mode) {
+    case STAKING_TX_MODE.single:
+      assert(steps.length === 1, 'single staking tx mode requires exactly one step')
+      return createSingleTx({
+        asset,
+        walletAccount,
+        step: steps[0],
+        gasPrice,
+        tipGasPrice,
+        feeData,
+      })
+    case STAKING_TX_MODE.bundle:
+      return createBundleTxs({ asset, walletAccount, fromAddress, steps, gasPrice, tipGasPrice })
+    default:
+      throw new Error(`Unknown staking tx mode: ${mode}`)
+  }
+}
+
+export async function sendStakingTxs({ asset, walletAccount, unsignedTxs, mode, onProgress }) {
+  switch (mode) {
+    case STAKING_TX_MODE.single: {
+      assert(unsignedTxs.length === 1, 'single staking tx mode requires exactly one tx')
+      onProgress?.({ index: 0, total: 1 })
+      const { txId } = await asset.baseAsset.api.sendTx({
+        asset,
+        walletAccount,
+        unsignedTx: unsignedTxs[0],
+      })
+      return { txIds: [txId] }
+    }
+
+    case STAKING_TX_MODE.bundle: {
+      const { bundleHash, txIds } = await asset.baseAsset.sendPrivateBundle({
+        unsignedTxBundle: unsignedTxs.map((unsignedTx) => ({ asset, unsignedTx, walletAccount })),
+        onBeforeSign: onProgress,
+      })
+      assert(txIds.length === unsignedTxs.length, 'expected a tx id for every bundled tx')
+      return { bundleHash, txIds: [...txIds] }
+    }
+
+    default:
+      throw new Error(`Unknown staking tx mode: ${mode}`)
+  }
+}

package/src/staking/matic/index.js

@@ -6,4 +6,5 @@ export {
   isPolygonReward,
   isPolygonClaimUndelegate,
   isPendingPolygonUndelegateTxInEthereumTxLog,
+  isPolygonUndelegateTxInEthereumTxLog,
 } from './matic-staking-utils.js'

package/src/tx-log/index.js

@@ -1,4 +1,3 @@
-export { EthereumMonitor } from './ethereum-monitor.js'
 export { EthereumNoHistoryMonitor } from './ethereum-no-history-monitor.js'
 export { ClarityMonitor } from './clarity-monitor.js'
 export { ClarityTruncatedHistoryMonitor } from './clarity-truncated-history-monitor.js'

package/src/tx-log/monitor-utils/index.js

@@ -1,8 +1,6 @@
 export { default as getDeriveDataNeededForTick } from './get-derive-data-needed-for-tick.js'
 
 export { default as getAllLogItemsByAsset } from './get-all-log-items-by-asset.js'
-export { default as getLogItemsFromServerTx } from './get-log-items-from-server-tx.js'
-export { default as getHistoryFromServer } from './get-history-from-server.js'
 export { default as checkPendingTransactions } from './check-pending-transactions.js'
 export { default as getDeriveTransactionsToCheck } from './get-derive-transactions-to-check.js'
 export { default as getCurrentEIP7702Delegation } from './get-current-eip7702-delegation.js'

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

@@ -1,276 +0,0 @@
-import { randomUUID } from '@exodus/crypto/randomUUID'
-import { bufferToHex } from '@exodus/ethereumjs/util'
-import fetchival from '@exodus/fetch/experimental/fetchival'
-import { retry } from '@exodus/simple-retry'
-import SolidityContract from '@exodus/solidity-contract'
-import ms from 'ms'
-
-import { fromHexToString } from '../number-utils.js'
-import { getFallbackGasPriceEstimation } from './utils.js'
-import createWebSocket from './ws.js'
-
-const RETRY_DELAYS = ['10s']
-
-export function create(defaultURL, ensAssetName) {
-  let API_URL = defaultURL
-  const ws = createWebSocket(() => {
-    const obj = new URL(API_URL)
-    obj.protocol = 'wss:'
-    return `${obj}`
-  })
-
-  function baseUrl(version = 'v1') {
-    return new URL(version === 'v1' ? API_URL : API_URL.replace('v1', version))
-  }
-
-  async function request(module, params = {}, { version = 'v1', method = 'get' } = {}) {
-    try {
-      return await fetchival(baseUrl(version), { timeout: ms('15s') })(module).method(
-        method,
-        params
-      )
-    } catch (err) {
-      let nerr = err
-      if (err.response && (err.response.status === 500 || err.response.status === 400)) {
-        try {
-          const data = await err.response.json()
-          const msg = data.error.replace(/^RPC error \(code: -\d+\): /, '')
-          nerr = new Error(msg)
-        } catch {}
-
-        nerr.finalError = true
-      }
-
-      throw nerr
-    }
-  }
-
-  // Default retry function
-  const requestWithRetry = retry(request, { delayTimesMs: RETRY_DELAYS })
-
-  return {
-    getURL() {
-      return API_URL
-    },
-
-    setURL(newURL) {
-      if (newURL === API_URL) return // prevents useless WS reconnections
-
-      API_URL = newURL || defaultURL
-
-      if (ws.isCreated()) {
-        ws.close()
-        ws.open()
-      }
-    },
-
-    stop() {
-      ws.close()
-    },
-
-    ws,
-
-    async getBalance(address, opts) {
-      opts = { startblock: 'earliest', endblock: 'pending', ...opts }
-      return requestWithRetry('balance', { address, from: opts.startblock, to: opts.endblock })
-    },
-
-    async getBalanceProxied(address, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getBalance', address, tag })
-    },
-
-    async balanceOf(address, tokenAddress, tag = 'latest') {
-      const contract = SolidityContract.simpleErc20(tokenAddress)
-      const callData = contract.balanceOf.build(address)
-      const data = {
-        data: bufferToHex(callData),
-        to: tokenAddress,
-        tag,
-      }
-      const result = await retry(this.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
-      const balance = fromHexToString(result)
-      return {
-        confirmed: {
-          [tokenAddress]: balance,
-        },
-      }
-    },
-
-    async getHistory(address, opts) {
-      opts = { startblock: 'earliest', endblock: 'pending', limit: 1000, ...opts }
-      return requestWithRetry('history', {
-        address,
-        from: opts.startblock,
-        to: opts.endblock,
-        limit: opts.limit,
-      })
-    },
-
-    async getHistoryV2(address, opts = {}) {
-      return requestWithRetry(
-        'history',
-        {
-          address,
-          ...opts,
-        },
-        { version: 'v2' }
-      )
-    },
-
-    async gasPrice() {
-      return requestWithRetry('proxy', { method: 'eth_gasPrice' })
-    },
-
-    async getGasPriceEstimation() {
-      return getFallbackGasPriceEstimation({ server: this })
-    },
-
-    // for fee monitor
-    async getGasPrice() {
-      return requestWithRetry('proxy', { method: 'eth_gasPrice' })
-    },
-
-    async getLatestBlock() {
-      return this.getBlockByNumber('latest')
-    },
-
-    async getBaseFeePerGas() {
-      const response = await this.getLatestBlock()
-      if (response.baseFeePerGas) {
-        return fromHexToString(response.baseFeePerGas)
-      }
-    },
-
-    async getTransactionCount(address, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getTransactionCount', address, tag })
-    },
-
-    async getTransactionByHash(hash) {
-      return requestWithRetry('proxy', { method: 'eth_getTransactionByHash', hash })
-    },
-
-    async getTransactionReceipt(txhash) {
-      return requestWithRetry('proxy', { method: 'eth_getTransactionReceipt', txhash })
-    },
-
-    async getCode(address, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getCode', address, tag })
-    },
-
-    async getStorageAt(address, slot, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_getStorageAt', address, slot, tag })
-    },
-
-    async isContract(address) {
-      const code = await requestWithRetry('proxy', { method: 'eth_getCode', address })
-      return code.length > 2
-    },
-
-    async sendRawTransaction(data) {
-      const _data = data instanceof Uint8Array ? Buffer.from(data).toString('hex') : data
-      const hex = _data.startsWith('0x') ? _data : '0x' + _data
-      return requestWithRetry(
-        'proxy',
-        { method: 'eth_sendRawTransaction', params: [hex] },
-        { version: 'v2', method: 'post' }
-      )
-    },
-
-    async estimateGas(data, tag = 'latest') {
-      return requestWithRetry('proxy', { method: 'eth_estimateGas', ...data, tag })
-    },
-
-    /**
-     * Hits a magnifier endpoint returning maximum gas limit that a specified
-     * contract along with method consumed in the past.
-     * @param opts : Object with parameters
-     * @returns {Promise<*>}
-     */
-    async getGasEstimation({ address, data }) {
-      return requestWithRetry('gas-estimation', {
-        address,
-        data,
-      })
-    },
-
-    async ethCall(data, tag = 'latest') {
-      return request('proxy', { method: 'eth_call', ...data, tag })
-    },
-
-    async blockNumber() {
-      return requestWithRetry('proxy', { method: 'eth_blockNumber' })
-    },
-
-    async getBlockByNumber(number, isFullTransactions = false) {
-      return requestWithRetry('proxy', {
-        method: 'eth_getBlockByNumber',
-        number,
-        isFullTransactions,
-      })
-    },
-
-    async getLogs(params) {
-      return requestWithRetry('proxy', { method: 'eth_getLogs', ...params })
-    },
-
-    async simulateRawTransaction(rawTransaction, applyPending = true) {
-      rawTransaction = rawTransaction.replace('0x', '')
-      return request('proxy', {
-        method: 'debug_simulateRawTransaction',
-        rawTransaction,
-        applyPending,
-      })
-    },
-
-    async getCoinbase() {
-      return request('proxy', {
-        method: 'eth_coinbase',
-      })
-    },
-
-    async getBlockByHash(blockHash, fullTx = false) {
-      return request('proxy', {
-        method: 'eth_getBlockByHash',
-        blockHash,
-        fullTx,
-      })
-    },
-
-    async getBlockTransactionCountByHash(blockHash) {
-      return request('proxy', {
-        method: 'eth_getBlockTransactionCountByHash',
-        blockHash,
-      })
-    },
-
-    async getBlockTransactionCountByNumber(quantityOrTag) {
-      return request('proxy', {
-        method: 'eth_getBlockTransactionCountByNumber',
-        quantityOrTag,
-      })
-    },
-
-    async getCompilers() {
-      return request('proxy', {
-        method: 'eth_getCompilers',
-      })
-    },
-
-    async getNetVersion() {
-      return request('proxy', {
-        method: 'net_version',
-      })
-    },
-
-    async proxyToCoinNode(requestData) {
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.id) requestData.id = randomUUID()
-      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
-      if (!requestData.params) requestData.params = []
-
-      return request('proxy', requestData, { version: 'v2', method: 'post' })
-    },
-  }
-}

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

@@ -1,126 +0,0 @@
-import EventEmitter from 'events/events.js' // forces it to use the module from node_modules
-import ms from 'ms'
-
-const RECONNECT_INTERVAL = ms('10s')
-const PING_INTERVAL = ms('10s')
-const MAX_RECONNECT_DELAY = ms('15s')
-
-export default function createWebSocket(getURL) {
-  const addresses = new Set()
-  const events = new EventEmitter()
-  let ws
-  let pingIntervalId = null
-  let opened = false
-  let isWSOpened = false
-  let openTimeoutId
-
-  function subscribeAddress(address) {
-    const data = JSON.stringify({ type: 'subscribe-address', address })
-    ws.send(data)
-  }
-
-  function subscribeGasPrice() {
-    const data = JSON.stringify({ type: 'subscribe-gasprice' })
-    ws.send(data)
-  }
-
-  function clearPing() {
-    clearInterval(pingIntervalId)
-    pingIntervalId = null
-  }
-
-  function onMessage(data) {
-    data = JSON.parse(data)
-    switch (data.type) {
-      case 'address':
-        events.emit(`address-${data.address}`)
-        break
-      case 'gasprice':
-        events.emit('gasprice', { gasPrice: data.gasprice, baseFeePerGas: data.baseGasPrice })
-        break
-    }
-  }
-
-  function open() {
-    opened = true
-    clearTimeout(openTimeoutId)
-    if (ws) return
-
-    ws = new WebSocket(getURL())
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onerror = (e) => {}
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onmessage = (e) => {
-      try {
-        onMessage(e.data)
-      } catch {}
-    }
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onopen = () => {
-      for (const address of addresses.values()) subscribeAddress(address)
-      subscribeGasPrice()
-      if (typeof ws.ping === 'function') {
-        pingIntervalId = setInterval(() => ws.ping(), PING_INTERVAL)
-      } else {
-        console.warn('Client side ping not available')
-      }
-
-      isWSOpened = true
-      events.emit('open')
-    }
-
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onclose = () => {
-      ws = null
-      isWSOpened = false
-      clearPing()
-      if (opened) {
-        openTimeoutId = setTimeout(open, reconnectDelay())
-      }
-
-      events.emit('close')
-    }
-  }
-
-  function close() {
-    opened = false
-    isWSOpened = false
-    clearTimeout(openTimeoutId)
-    if (!ws) return
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onerror = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onmessage = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onopen = null
-    // eslint-disable-next-line unicorn/prefer-add-event-listener
-    ws.onclose = null
-    try {
-      ws.close()
-    } catch (e) {
-      if (!/WebSocket was closed before the connection was established/.test(e.message)) {
-        throw e
-      }
-    }
-
-    ws = null
-    clearPing()
-    events.emit('close')
-  }
-
-  function reconnectDelay() {
-    const min = RECONNECT_INTERVAL
-    const max = MAX_RECONNECT_DELAY
-    return Math.floor(Math.random() * (max - min + 1) + min)
-  }
-
-  function watch(address) {
-    if (addresses.has(address)) return
-    addresses.add(address)
-
-    if (ws) subscribeAddress(address)
-  }
-
-  return { events, open, close, watch, isCreated: () => !!ws, isOpened: () => isWSOpened }
-}