@exodus/ethereum-api 8.76.6 → 8.76.7

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

@@ -22,7 +22,11 @@ const DYNAMIC_RPC_ERRORS = {
   TRANSACTION_GAS_PRICE_BELOW_MINIMUM: safeString`transaction gas price below minimum`,
 }
 
-export const KNOWN_RPC_ERRORS = { ...TxPoolErrors, ...DYNAMIC_RPC_ERRORS }
+const SERVO_ERRORS = {
+  EMPTY_BUNDLE: safeString`numTxs=0: invalid num txs`,
+}
+
+export const KNOWN_RPC_ERRORS = { ...TxPoolErrors, ...DYNAMIC_RPC_ERRORS, ...SERVO_ERRORS }
 
 export const tryMappingToRpcErrors = (errorMessage) => {
   if (typeof errorMessage !== 'string') return

package/src/exodus-eth-server/eth-like-server-base.js

@@ -0,0 +1,123 @@
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import SolidityContract from '@exodus/solidity-contract'
+import EventEmitter from 'events/events.js'
+import assert from 'minimalistic-assert'
+
+export default class EthLikeServerBase extends EventEmitter {
+  id = 0
+
+  buildRequest({ method, params = [] }) {
+    return { jsonrpc: '2.0', id: this.id++, method, params }
+  }
+
+  balanceOfRequest(address, tokenAddress, tag = 'latest') {
+    const contract = SolidityContract.simpleErc20(tokenAddress)
+    const callData = contract.balanceOf.build(address)
+    const data = {
+      data: bufferToHex(callData),
+      to: tokenAddress,
+    }
+    return this.ethCallRequest(data, tag)
+  }
+
+  getBalanceRequest(address, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getBalance', params: [address, tag] })
+  }
+
+  gasPriceRequest() {
+    return this.buildRequest({ method: 'eth_gasPrice' })
+  }
+
+  estimateGasRequest(data, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_estimateGas', params: [data, tag] })
+  }
+
+  sendRawTransactionRequest(data) {
+    const _data = data instanceof Uint8Array ? Buffer.from(data).toString('hex') : data
+    const hex = _data.startsWith('0x') ? _data : '0x' + _data
+    return this.buildRequest({ method: 'eth_sendRawTransaction', params: [hex] })
+  }
+
+  coinbaseRequest() {
+    return this.buildRequest({ method: 'eth_coinbase' })
+  }
+
+  getCodeRequest(address, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getCode', params: [address, tag] })
+  }
+
+  getStorageAtRequest(address, position, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getStorageAt', params: [address, position, tag] })
+  }
+
+  getTransactionCountRequest(address, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_getTransactionCount', params: [address, tag] })
+  }
+
+  getTransactionByHashRequest(hash) {
+    return this.buildRequest({ method: 'eth_getTransactionByHash', params: [hash] })
+  }
+
+  getTransactionReceiptRequest(txhash) {
+    return this.buildRequest({ method: 'eth_getTransactionReceipt', params: [txhash] })
+  }
+
+  ethCallRequest(data, tag = 'latest') {
+    return this.buildRequest({ method: 'eth_call', params: [data, tag] })
+  }
+
+  blockNumberRequest() {
+    return this.buildRequest({ method: 'eth_blockNumber' })
+  }
+
+  getLogsRequest(object) {
+    return this.buildRequest({ method: 'eth_getLogs', params: [object] })
+  }
+
+  getBlockByNumberRequest(numberHex, isFullTxs = false) {
+    return this.buildRequest({ method: 'eth_getBlockByNumber', params: [numberHex, isFullTxs] })
+  }
+
+  getBlockByHashRequest(blockHash, isFullTxs = false) {
+    return this.buildRequest({ method: 'eth_getBlockByHash', params: [blockHash, isFullTxs] })
+  }
+
+  getBlockTransactionCountByHashRequest(blockHash) {
+    return this.buildRequest({ method: 'eth_getBlockTransactionCountByHash', params: [blockHash] })
+  }
+
+  getBlockTransactionCountByNumberRequest(quantityOrTag) {
+    return this.buildRequest({
+      method: 'eth_getBlockTransactionCountByNumber',
+      params: [quantityOrTag],
+    })
+  }
+
+  getCompilersRequest() {
+    return this.buildRequest({ method: 'eth_getCompilers' })
+  }
+
+  simulateV1Request(...params) {
+    return this.buildRequest({
+      method: 'eth_simulateV1',
+      params,
+    })
+  }
+
+  getNetVersionRequest() {
+    return this.buildRequest({ method: 'net_version' })
+  }
+
+  simulateRawTransactionRequest(rawTx, applyPending = true) {
+    const replaced = rawTx.replace('0x', '')
+    return this.buildRequest({
+      method: 'debug_simulateRawTransaction',
+      params: [replaced, applyPending],
+    })
+  }
+
+  sendBundleRequest({ txs }) {
+    assert(Array.isArray(txs), 'expected array txs')
+    return this.buildRequest({ method: 'eth_sendBundle', params: [{ txs }] })
+  }
+}

package/src/exodus-eth-server/fetch-json.js

@@ -0,0 +1,48 @@
+import { retry } from '@exodus/simple-retry'
+import { TraceId } from '@exodus/traceparent'
+
+const getTextFromResponse = async (response) => {
+  try {
+    const responseBody = await response.text()
+    return responseBody.slice(0, 100)
+  } catch {
+    return ''
+  }
+}
+
+export const fetchJson = async (url, fetchOptions) => {
+  const response = await fetch(url, fetchOptions)
+
+  if (!response.ok) {
+    const traceId = TraceId.fromResponse(response)
+    const error = new Error(
+      `${url} returned ${response.status}: ${
+        response.statusText || 'Unknown Status Text'
+      }. Body: ${await getTextFromResponse(response)}`
+    )
+    if (traceId) {
+      error.traceId = traceId
+    }
+
+    throw error
+  }
+
+  const json = await response.json()
+
+  // Only capture trace ID if there's an RPC error in the response
+  // (consumers extract it via __traceId when throwing the error)
+  if (json.error) {
+    const traceId = TraceId.fromResponse(response)
+    if (traceId) {
+      json.__traceId = traceId
+    }
+  }
+
+  return json
+}
+
+export const fetchJsonRetry = (url, fetchOptions) => {
+  const waitTimes = ['3s']
+  const fetchWithRetry = retry(fetchJson, { delayTimesMs: waitTimes })
+  return fetchWithRetry(url, fetchOptions)
+}

package/src/gas-estimation.js

@@ -98,12 +98,27 @@ export async function resolveGasLimitMultiplier({ asset, feeData, toAddress, fro
   return DEFAULT_GAS_LIMIT_MULTIPLIER
 }
 
+// https://eips.ethereum.org/EIPS/eip-7623
+export const getEip7623CalldataCost = (calldata) => {
+  calldata = toBuffer(calldata)
+
+  const TOTAL_COST_FLOOR_PER_TOKEN = 10
+
+  const nonZeroBytesInCalldata = calldata.filter(Boolean).length
+  const zeroBytesInCalldata = calldata.length - nonZeroBytesInCalldata
+  const tokensInCalldata = zeroBytesInCalldata + nonZeroBytesInCalldata * 4
+
+  return TOTAL_COST_FLOOR_PER_TOKEN * tokensInCalldata
+}
+
 export const defaultGasLimit = ({ asset, txInput }) => {
   const isToken = isEthereumLikeToken(asset)
-  return (
-    (isToken ? DEFAULT_TOKEN_GAS_LIMIT : DEFAULT_GAS_LIMIT) +
-    GAS_PER_NON_ZERO_BYTE * toBuffer(txInput).length
-  )
+
+  const calldataCost = asset.baseAsset.eip7623Supported
+    ? getEip7623CalldataCost(txInput)
+    : GAS_PER_NON_ZERO_BYTE * toBuffer(txInput).length
+
+  return (isToken ? DEFAULT_TOKEN_GAS_LIMIT : DEFAULT_GAS_LIMIT) + calldataCost
 }
 
 // TODO: `gasLimit` needs to be a responsibility of `resolveTxAttributesByTxType`.

package/src/get-balances.js

@@ -293,6 +293,20 @@ export const getBalancesFactory = ({ monitorType, useAbsoluteBalance, rpcBalance
       }
     }
 
+    // A pending send already reflected in the account-state reading is double-counted
+    // via `unconfirmedSent`, making spendable transiently negative (bounded by
+    // `unconfirmedSent`). A negative beyond that bound is a real accounting bug.
+    if (spendable.isNegative && spendable.abs().gt(unconfirmedSent)) {
+      console.warn('unexpected negative spendable beyond pending sends', {
+        assetName: asset.name,
+        spendable: spendable.toBaseString(),
+        unconfirmedSent: unconfirmedSent.toBaseString(),
+      })
+    }
+
+    // Clamp before deriving `total` so the artifact doesn't drag it below staked balances.
+    spendable = spendable.clampLowerZero()
+
     const total = spendable.add(staked).add(staking).add(unstaking).add(unstaked)
     const stakeable = spendable
 

package/src/index.js

@@ -61,6 +61,7 @@ export {
 } from './staking/index.js'
 
 export { fetchTxPreview, maybeRemoveDuplicates, retrieveSideEffects } from './simulate-tx/index.js'
+export { simulateTransactions } from './simulation/simulate-transactions.js'
 
 export {
   isZeroAllowanceAsset,

package/src/multicall3/index.js

@@ -0,0 +1,169 @@
+import { memoize } from '@exodus/basic-utils'
+import { ABI } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import SolidityContract from '@exodus/solidity-contract'
+import assert from 'minimalistic-assert'
+
+import EthLikeServerBase from '../exodus-eth-server/eth-like-server-base.js'
+import { BLOCK_TAG_LATEST } from '../tx-send/nonce-utils.js'
+
+const assertValidMulticall3BlockTag = (blockTag) =>
+  assert(blockTag === BLOCK_TAG_LATEST, 'blockTag must be "latest" for multicall3')
+
+const SUPPORTED_METHODS = new Set(['eth_getBalance', 'eth_blockNumber', 'eth_call'])
+
+const assertSupportedMethod = (method) => {
+  assert(
+    SUPPORTED_METHODS.has(method),
+    `method "${method}" is not supported for static call batching`
+  )
+}
+
+const getMulticall3Contract = memoize(() => new SolidityContract(ABI.multicall3))
+
+export class EthLikeRpcRequestAccumulator extends EthLikeServerBase {
+  #requestContext = null
+  #requests = []
+
+  #withRequestContext(requestContext, ...args) {
+    assert(this.#requestContext === null)
+    this.#requestContext = requestContext
+
+    const result = super[requestContext](...args)
+
+    this.#requestContext = null
+    return result
+  }
+
+  _serializeRequest({ context: _, originalRequest }) {
+    return super.buildRequest(originalRequest)
+  }
+
+  async _execute({ requests, server }) {
+    return server.sendBatchRequest(requests.map(({ request }) => request))
+  }
+
+  buildRequest(originalRequest) {
+    const { method, params } = originalRequest
+    assertSupportedMethod(method)
+
+    if (method === 'eth_getBalance' || method === 'eth_call') {
+      const tag = params[1]
+      assertValidMulticall3BlockTag(tag)
+    }
+
+    const context = this.#requestContext ?? method
+
+    void this.#requests.push({
+      context,
+      originalRequest,
+      request: this._serializeRequest({ context, originalRequest }),
+    })
+
+    return this
+  }
+
+  balanceOfRequest(...args) {
+    return this.#withRequestContext('balanceOfRequest', ...args)
+  }
+
+  length() {
+    return this.#requests.length
+  }
+
+  reset() {
+    this.#requests.length = 0
+  }
+
+  async flush(server) {
+    assert(server, 'expected server')
+
+    const requests = [...this.#requests]
+    this.reset()
+
+    if (requests.length === 0) return []
+
+    const results = await this._execute({ requests, server })
+
+    return results.map((result, i) => {
+      const request = requests[i]
+      assert(request)
+
+      const { context, originalRequest } = request
+
+      if (context === 'eth_getBalance') return `0x${BigInt(result).toString(16)}`
+      if (context === 'eth_blockNumber') return `0x${BigInt(result).toString(16)}`
+      if (context === 'balanceOfRequest') {
+        const {
+          params: [{ to: tokenAddress }],
+        } = originalRequest
+        return {
+          confirmed: {
+            [tokenAddress]: BigInt(result).toString(),
+          },
+        }
+      }
+
+      return result
+    })
+  }
+}
+
+export class EthLikeMulticall3RpcRequestAccumulator extends EthLikeRpcRequestAccumulator {
+  #multicall3Address
+  #multicall3Contract
+
+  constructor({ multicall3Address }) {
+    super()
+
+    assert(typeof multicall3Address === 'string')
+    this.#multicall3Address = multicall3Address
+    this.#multicall3Contract = getMulticall3Contract()
+  }
+
+  _serializeRequest({ context: _, originalRequest: { method, params } }) {
+    switch (method) {
+      case 'eth_getBalance':
+        return {
+          address: this.#multicall3Address,
+          calldata: bufferToHex(this.#multicall3Contract.getEthBalance.build(params[0])),
+        }
+      case 'eth_blockNumber':
+        return {
+          address: this.#multicall3Address,
+          calldata: bufferToHex(this.#multicall3Contract.getBlockNumber.build()),
+        }
+      case 'eth_call': {
+        const [data] = params
+        const { to, data: calldata } = data
+        return { address: to, calldata }
+      }
+
+      default:
+        assert(false)
+    }
+  }
+
+  async _execute({ requests, server }) {
+    const data = await server.ethCall({
+      data: bufferToHex(
+        this.#multicall3Contract.aggregate.build(
+          requests.map(({ request: { address, calldata } }) => [address, calldata])
+        )
+      ),
+      to: this.#multicall3Address,
+    })
+
+    const multicall3Result = this.#multicall3Contract.decodeOutput({ data, method: 'aggregate' })
+
+    assert(
+      Array.isArray(multicall3Result) && multicall3Result.length === 2,
+      'invalid multicall3Result'
+    )
+
+    const results = multicall3Result[1].map((buf) => bufferToHex(buf))
+    assert(results.length === requests.length)
+
+    return results
+  }
+}

package/src/simulation/common.js

@@ -0,0 +1,34 @@
+import BN from 'bn.js'
+
+export const BLOWFISH_EVM_CHAINS = {
+  avalanchec: {
+    network: 'avalanche',
+    chain: 'mainnet',
+  },
+  basemainnet: {
+    network: 'base',
+    chain: 'mainnet',
+  },
+  bsc: {
+    network: 'bnb',
+    chain: 'mainnet',
+  },
+  ethereum: {
+    network: 'ethereum',
+    chain: 'mainnet',
+  },
+  ethereumarbone: {
+    network: 'arbitrum',
+    chain: 'one',
+  },
+  matic: {
+    network: 'polygon',
+    chain: 'mainnet',
+  },
+  optimism: {
+    network: 'optimism',
+    chain: 'mainnet',
+  },
+}
+
+export const MAX_INT256_SOLIDITY = new BN(2).pow(new BN(255)).subn(1)

package/src/simulation/create-simulate-message.js

@@ -0,0 +1,49 @@
+import { tryParsingSIWE } from '@exodus/web3-utils'
+import assert from 'minimalistic-assert'
+
+import { getMessageType, MessageTypeEnum } from './get-message-type.js'
+import { simulateMessageApi } from './simulate-message-api.js'
+
+export const createSimulateMessage =
+  ({
+    apiEndpoint = 'https://simulation.a.exodus.io/simulateMessage',
+    headers = {
+      'X-Api-Version': '2023-06-05',
+    },
+  } = {}) =>
+  async ({ message, url, asset, address }) => {
+    assert(url instanceof URL, "'url' should be an instance of the URL object.")
+
+    const simulationResult = {
+      baseAssetName: asset.baseAssetName,
+      action: 'NONE',
+    }
+
+    const messageType = getMessageType(message)
+    if (messageType === MessageTypeEnum.Unknown) {
+      return simulationResult
+    }
+
+    if (messageType === MessageTypeEnum.RawMessage) {
+      tryParsingSIWE({
+        address,
+        message,
+        url,
+        simulationResult,
+      })
+    }
+
+    await simulateMessageApi({
+      address,
+      message: {
+        message,
+        messageType,
+      },
+      url,
+      apiEndpoint,
+      headers,
+      simulationResult,
+    })
+
+    return simulationResult
+  }

package/src/simulation/create-simulate-transactions.js

@@ -0,0 +1,106 @@
+import { createEmptySimulationResult } from '@exodus/web3-utils'
+
+import { estimateFee } from './estimate-fee.js'
+import { simulateTransactionsApi } from './simulate-transactions-api.js'
+import { decodeRecipientAddresses, getDisplayDetails, getTxFeeDetails } from './transactions.js'
+import { tryEstimatingChangesLocally } from './try-estimating-changes-locally.js'
+
+export const createSimulateTransactions =
+  ({ apiEndpoint, headers: headersFromDeps }) =>
+  async ({
+    transactions,
+    asset,
+    origin,
+    blockNumber,
+    headers: headersFromParams,
+    overrideApiEndpoint,
+  }) => {
+    const headers = { ...headersFromDeps, ...headersFromParams }
+
+    const simulationResult = createEmptySimulationResult({
+      asset,
+    })
+
+    if (transactions.length === 0) {
+      const message = 'No transactions provided. Cannot simulate transaction batch.'
+      simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+      simulationResult.metadata.humanReadableError = message
+      return simulationResult
+    }
+
+    const firstFrom = transactions[0].from.toLowerCase()
+    const hasMismatchedFrom = transactions.some((tx) => tx.from.toLowerCase() !== firstFrom)
+    if (hasMismatchedFrom) {
+      const message =
+        'All transactions in a batch must have the same "from" address. Cannot simulate transaction batch.'
+      simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+      simulationResult.metadata.humanReadableError = message
+      return simulationResult
+    }
+
+    const hasInvalidTransaction = transactions.some((tx) => !tx.to)
+    if (hasInvalidTransaction) {
+      const message =
+        'One or more transactions are missing required "to" address. Cannot simulate transaction batch.'
+      simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+      simulationResult.metadata.humanReadableError = message
+      return simulationResult
+    }
+
+    simulationResult.recipientAddresses = transactions.map((tx) => decodeRecipientAddresses(tx))
+    const feeCurrency = asset.feeAsset.currency
+
+    const simulationTransactionInternalResult = await simulateTransactionsApi({
+      asset,
+      transactions,
+      apiEndpoint: overrideApiEndpoint || apiEndpoint,
+      origin,
+      blockNumber,
+      simulationResult,
+      headers,
+    })
+
+    if (simulationTransactionInternalResult.kind === 'error') {
+      if (transactions.length > 1) {
+        const message = 'Cannot locally simulate batched transactions.'
+        simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+        simulationResult.metadata.humanReadableError = message
+      } else {
+        const transaction = transactions[0]
+        const simulatedLocally = tryEstimatingChangesLocally({
+          asset,
+          simulationResult,
+          transaction,
+        })
+        if (simulatedLocally) {
+          simulationResult.metadata.simulatedLocally = true
+          simulationResult.balanceChanges.willPayFee.push({
+            balance: estimateFee({ feeCurrency, transaction }),
+            feeDetails: getTxFeeDetails(transaction),
+          })
+        } else {
+          const message = 'Balance changes cannot be estimated.'
+          simulationResult.warnings.push({ kind: 'INTERNAL_ERROR', severity: 'HIGH', message })
+          simulationResult.metadata.humanReadableError = message
+        }
+      }
+
+      if (simulationTransactionInternalResult.errorMessage) {
+        simulationResult.metadata.humanReadableError =
+          simulationTransactionInternalResult.errorMessage
+      }
+
+      return simulationResult
+    }
+
+    for (const transaction of transactions) {
+      simulationResult.balanceChanges.willPayFee.push({
+        balance: estimateFee({ feeCurrency, transaction }),
+        feeDetails: getTxFeeDetails(transaction),
+      })
+    }
+
+    simulationResult.displayDetails = getDisplayDetails(simulationResult.balanceChanges.willApprove)
+
+    return simulationResult
+  }

package/src/simulation/estimate-fee.js

@@ -0,0 +1,14 @@
+import { hexToBN } from '@exodus/web3-utils'
+
+export const estimateFee = ({ feeCurrency, transaction }) => {
+  const gas = hexToBN(transaction.gas)
+
+  if (transaction.maxFeePerGas) {
+    const maxFeePerGas = hexToBN(transaction.maxFeePerGas)
+    const maximumFee = gas.mul(maxFeePerGas)
+    return feeCurrency.baseUnit(maximumFee.toString())
+  }
+
+  const gasPrice = hexToBN(transaction.gasPrice)
+  return feeCurrency.baseUnit(gas.mul(gasPrice).toString())
+}

package/src/simulation/estimate-simple-transfer.js

@@ -0,0 +1,15 @@
+import { hexToBN } from '@exodus/web3-utils'
+
+import { isSimpleTransfer } from './transactions.js'
+
+export class NotSimpleTransferError extends Error {}
+
+export const estimateSimpleTransfer = ({ baseAsset, transaction }) => {
+  if (!isSimpleTransfer(transaction)) {
+    throw new NotSimpleTransferError('The transaction input should be empty ("0x").')
+  }
+
+  const txValue = hexToBN(transaction.value || '0x0').toString()
+
+  return baseAsset.currency.baseUnit(txValue)
+}

package/src/simulation/get-message-type.js

@@ -0,0 +1,18 @@
+export const MessageTypeEnum = {
+  RawMessage: 0,
+  TypedData: 1,
+  Unknown: 2,
+}
+
+export const getMessageType = (message) => {
+  if (typeof message !== 'string') {
+    return MessageTypeEnum.Unknown
+  }
+
+  try {
+    JSON.parse(message)
+    return MessageTypeEnum.TypedData
+  } catch {
+    return MessageTypeEnum.RawMessage
+  }
+}