@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.1

package/src/eth-like-util.js

@@ -1,12 +1,25 @@
-import assert from 'minimalistic-assert'
-import { normalizeTxId, isEthereumLikeAsset, isEthereumLikeToken, ABI } from '@exodus/ethereum-lib'
 import { memoizeLruCache } from '@exodus/asset-lib'
+import { ABI, isEthereumLikeAsset, isEthereumLikeToken, normalizeTxId } from '@exodus/ethereum-lib'
+import { safeString } from '@exodus/safe-string'
 import SolidityContract from '@exodus/solidity-contract'
-import { getServer } from './exodus-eth-server/server-map'
-import { fromHexToString } from './number-utils'
+import assert from 'minimalistic-assert'
+
+import { EthLikeError, EVM_ERROR_REASONS, withErrorReason } from './error-wrapper.js'
+import { getServer } from './exodus-eth-server/index.js'
+import { fromHexToString } from './number-utils.js'
+
+export const FORWARDER_CONTRACT_CODE =
+  '0x5836818037808036817364b29dc43e817817cf77468c8dda63d98ce08fb25af43d91908282803e602b57fd5bf3'
+
+export const EIP7702_DELEGATION_DESIGNATOR = '0xef0100'
 
 export async function isContractAddress({ asset, address }) {
-  return getServer(asset).isContract(address)
+  return withErrorReason({
+    promise: getServer(asset).isContract(address),
+    errorReasonInfo: EVM_ERROR_REASONS.getCodeFailed,
+    hint: safeString`isContractAddress`,
+    baseAssetName: asset.baseAsset.name,
+  })
 }
 
 export const isContractAddressCached = memoizeLruCache(
@@ -16,11 +29,14 @@ export const isContractAddressCached = memoizeLruCache(
 )
 
 export async function isForwarderContract({ asset, address }) {
-  const contractCode = await getServer(asset).getCode(address)
-  return (
-    contractCode ===
-    '0x5836818037808036817364b29dc43e817817cf77468c8dda63d98ce08fb25af43d91908282803e602b57fd5bf3'
-  )
+  const server = getServer(asset)
+  const contractCode = await withErrorReason({
+    promise: server.getCode(address),
+    errorReasonInfo: EVM_ERROR_REASONS.getCodeFailed,
+    hint: safeString`isForwarderContract`,
+    baseAssetName: asset.baseAsset.name,
+  })
+  return contractCode === FORWARDER_CONTRACT_CODE
 }
 
 export const isForwarderContractCached = memoizeLruCache(
@@ -31,62 +47,103 @@ export const isForwarderContractCached = memoizeLruCache(
 
 export async function getNonce({ asset, address, tag = 'latest' }) {
   const server = getServer(asset)
-  const nonce = await server.getTransactionCount(address, tag)
+  const nonce = await withErrorReason({
+    promise: server.getTransactionCount(address, tag),
+    errorReasonInfo: EVM_ERROR_REASONS.nonceFetchFailed,
+    hint: safeString`getNonce`,
+    baseAssetName: asset.baseAsset.name,
+  })
+
   return parseInt(nonce, 16)
 }
 
 export async function estimateGas({ asset, ...args }) {
-  return getServer(asset).estimateGas(args)
+  return withErrorReason({
+    promise: getServer(asset).estimateGas(args),
+    errorReasonInfo: EVM_ERROR_REASONS.fetchGasLimitFailed,
+    hint: safeString`estimateGas`,
+    baseAssetName: asset.baseAsset.name,
+  })
 }
 
 // Only base assets, not tokens
 export async function getBalance({ asset, address }) {
   if (!isEthereumLikeAsset(asset)) throw new Error(`unsupported asset ${asset.name}`)
+
   const server = getServer(asset)
-  const balances = await server.getBalance(address)
+  const balances = await withErrorReason({
+    promise: server.getBalance(address),
+    errorReasonInfo: EVM_ERROR_REASONS.balanceFetchFailed,
+    hint: safeString`getBalance`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return balances?.confirmed?.value || '0'
 }
 
 // Only base assets, not tokens
 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 result = await withErrorReason({
+    promise: getServer(asset).getBalanceProxied(address),
+    errorReasonInfo: EVM_ERROR_REASONS.balanceFetchFailed,
+    hint: safeString`getBalanceProxied`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return fromHexToString(result)
 }
 
 // Only ETH-like assets with token support
+// How would this return token balances? It does the same as getBalanceProxied... getting ETH balance
 export async function getTokenBalance({ asset, address }) {
   if (!isEthereumLikeToken(asset)) throw new Error(`unsupported ETH-like token ${asset.name}`)
-  const server = getServer(asset)
-  const balances = await server.getBalance(address)
+
   const contractAddress = asset.contract.address.toLowerCase()
+  const server = getServer(asset)
+  const balances = await withErrorReason({
+    promise: server.balanceOf(address, contractAddress),
+    errorReasonInfo: EVM_ERROR_REASONS.balanceFetchFailed,
+    hint: safeString`getTokenBalance`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return balances?.confirmed?.[contractAddress] || '0'
 }
 
 export async function getTokenBalanceFromNode({ asset, address }) {
   if (!isEthereumLikeToken(asset)) throw new Error(`unsupported ETH-like token ${asset.name}`)
+
   const server = getServer(asset)
   const contractAddress = asset.contract.address.toLowerCase()
-  const balances = await server.balanceOf(address, contractAddress)
+  const balances = await withErrorReason({
+    promise: server.balanceOf(address, contractAddress),
+    errorReasonInfo: EVM_ERROR_REASONS.ethCallErc20Failed,
+    hint: safeString`getTokenBalanceFromNode`,
+    baseAssetName: asset.baseAsset.name,
+  })
   return balances?.confirmed?.[contractAddress] || '0'
 }
 
-// Returns function for supplied asset
-export function sendRawTransaction(asset) {
-  return getServer(asset).sendRawTransaction
-}
-
 export async function transactionExists({ asset, txId }) {
   const server = getServer(asset)
   txId = normalizeTxId(txId)
-  const txResult = await server.getTransactionByHash(txId)
-  return txResult && txResult.hash === txId
+  const txResult = await withErrorReason({
+    promise: server.getTransactionByHash(txId),
+    errorReasonInfo: EVM_ERROR_REASONS.getTransactionByHashFailed,
+    hint: safeString`transactionExists`,
+    baseAssetName: asset.baseAsset.name,
+  })
+  return Boolean(txResult && txResult.hash === txId)
 }
 
 export async function getTransaction({ asset, txId }) {
   const server = getServer(asset)
   txId = normalizeTxId(txId)
-  return server.getTransactionByHash(txId)
+  return withErrorReason({
+    promise: server.getTransactionByHash(txId),
+    errorReasonInfo: EVM_ERROR_REASONS.getTransactionByHashFailed,
+    hint: safeString`getTransaction`,
+    baseAssetName: asset.baseAsset.name,
+  })
 }
 
 export const getIsForwarderContract = memoizeLruCache(
@@ -97,8 +154,9 @@ export const getIsForwarderContract = memoizeLruCache(
 
 const ERC20 = new SolidityContract(ABI.erc20)
 const ERC20BytesParams = new SolidityContract(ABI.erc20BytesParams)
+const ERC721 = new SolidityContract(ABI.erc721)
 const DEFAULT_PARAM_NAMES = ['decimals', 'name', 'symbol']
-const erc20ParamsCache = {}
+const erc20ParamsCache = Object.create(null)
 
 export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARAM_NAMES } = {}) => {
   assert(asset, 'getERC20Params(): asset required')
@@ -117,13 +175,13 @@ export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARA
       try {
         callResponse = await server.ethCall({ to: address, data: ERC20[method].methodId })
       } catch (err) {
-        if (err.message === 'execution reverted') {
-          throw new Error(
-            `Can't find parameters for contract with address ${address}. Are you sure it is a valid ERC20 contract?`
-          )
-        }
-
-        throw new Error(err.message)
+        throw new EthLikeError({
+          message: err.message,
+          errorReasonInfo: EVM_ERROR_REASONS.ethCallErc20Failed,
+          hint: safeString`getERC20Params`,
+          traceId: err.traceId,
+          baseAssetName: asset.baseAsset.name,
+        })
       }
 
       if (method === 'decimals') return parseInt(callResponse)
@@ -150,3 +208,84 @@ export const getERC20Params = async ({ asset, address, paramNames = DEFAULT_PARA
 
   return response
 }
+
+// ERC-165 introspection used to drive Ledger's clear-signing for contract calls:
+// it tells the device whether the target is an NFT (ERC-721/1155) or a fungible
+// token. See `signHardwareFactory` in ethereum-lib for how this feeds the device's
+// `isNft` hint. Display-only: never affects the signed transaction.
+const buildSupportsInterfaceData = (interfaceId) => {
+  const erc165InterfaceId = `0x${interfaceId}`
+  return `0x${ERC721.supportsInterface.build(erc165InterfaceId).toString('hex')}`
+}
+
+const decodeBool = (result) => {
+  return ERC721.decodeOutput({ method: 'supportsInterface', data: result })[0]
+}
+
+// true = supported, false = not supported / reverted, undefined = transport failure
+const probeSupportsInterface = async ({ server, address, interfaceId }) => {
+  try {
+    const result = await server.ethCall({
+      to: address,
+      data: buildSupportsInterfaceData(interfaceId),
+    })
+    return decodeBool(result)
+  } catch (err) {
+    // Empirically, a contract without supportsInterface comes through Clarity as
+    // "Bad rpc response: execution reverted". Unknown errors stay undefined so
+    // we don't force a wrong hint.
+    const EXECUTION_REVERT_MESSAGE = 'execution reverted'
+    const errorMessage = err?.message || String(err || '')
+    return errorMessage.toLowerCase().includes(EXECUTION_REVERT_MESSAGE) ? false : undefined
+  }
+}
+
+// Resolves whether `address` is an NFT contract (ERC-721 or ERC-1155) via ERC-165.
+// Returns true (NFT), false (not an NFT), or undefined (couldn't determine).
+export async function getIsNftContract({ server, address }) {
+  assert(server, 'getIsNftContract(): server required')
+  assert(address, 'getIsNftContract(): address required')
+
+  const ERC721_INTERFACE_ID = '80ac58cd'
+  const ERC1155_INTERFACE_ID = 'd9b67a26'
+
+  const [isErc721, isErc1155] = await Promise.all([
+    probeSupportsInterface({ server, address, interfaceId: ERC721_INTERFACE_ID }),
+    probeSupportsInterface({ server, address, interfaceId: ERC1155_INTERFACE_ID }),
+  ])
+
+  if (isErc721 === true || isErc1155 === true) {
+    return true
+  }
+
+  if (isErc721 === false && isErc1155 === false) return false
+}
+
+export async function getEIP7702Delegation({ address, server }) {
+  const code = await withErrorReason({
+    promise: server.getCode(address),
+    errorReasonInfo: EVM_ERROR_REASONS.getCodeFailed,
+    hint: safeString`getEIP7702Delegation`,
+    baseAssetName: server.baseAssetName,
+  })
+
+  // No code at all
+  if (!code || code === '0x' || code === '0x0') {
+    return { isDelegated: false, delegatedAddress: null }
+  }
+
+  // EIP-7702 delegation code must be exactly 23 bytes (46 hex chars + "0x" prefix = 48 chars)
+  // Format: 0xef0100 (3 bytes) + address (20 bytes)
+  if (code.length !== 48) {
+    return { isDelegated: false, delegatedAddress: null }
+  }
+
+  // Check for EIP-7702 delegation designator prefix
+  if (!code.toLowerCase().startsWith(EIP7702_DELEGATION_DESIGNATOR)) {
+    return { isDelegated: false, delegatedAddress: null }
+  }
+
+  // Extract the 20-byte delegated address
+  const delegatedAddress = '0x' + code.slice(8, 48)
+  return { isDelegated: true, delegatedAddress }
+}

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

@@ -1,16 +1,18 @@
-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'
+import { safeString } from '@exodus/safe-string'
+import lodash from 'lodash'
 
-export default class ApiCoinNodesServer extends EventEmitter {
-  constructor({ uri }) {
+import { errorMessageToSafeHint } from './errors.js'
+import { EthLikeServer } from './eth-like-server.js'
+import { fetchJsonRetry } from './fetch-json.js'
+
+const { isEmpty } = lodash
+
+export default class ApiCoinNodesServer extends EthLikeServer {
+  constructor({ baseAssetName, uri }) {
     super()
+    this.baseAssetName = baseAssetName
     this.uri = uri
     this.defaultUri = uri
-    this.id = 0
   }
 
   setURI(uri) {
@@ -24,24 +26,18 @@ export default class ApiCoinNodesServer extends EventEmitter {
       body: JSON.stringify(body),
     }
 
-    const response = await fetch(this.uri, options)
-    return response.json()
+    return fetchJsonRetry(this.uri, options)
   }
 
-  async sendBatchRequest(batch) {
+  async sendBatchRequest(batch, { tolerant } = {}) {
     if (isEmpty(batch)) return batch
     const responses = await this.request(batch)
-    const isValid = responses.every((response) => {
-      return !isNaN(response?.id) && response?.result
+    return this.parseBatchResponse({
+      batch,
+      responses,
+      errorMessage: 'Bad rpc batch response',
+      tolerant,
     })
-    if (responses.length !== batch.length || !isValid) {
-      throw new Error('Bad rpc batch response')
-    }
-
-    const keyed = responses.reduce((acc, response) => {
-      return { ...acc, [`${response.id}`]: response.result }
-    }, Object.create(null))
-    return batch.map((request) => keyed[`${request.id}`])
   }
 
   async sendRequest(request) {
@@ -50,185 +46,20 @@ export default class ApiCoinNodesServer extends EventEmitter {
     const result = response?.result
     const error = response?.error
     if (error || result === undefined) {
-      const message = error?.message || error?.code || 'no result'
-      throw new Error(`Bad rpc response: ${message}`)
-    }
+      const message = error?.message || error?.code || safeString`no result`
 
-    return result
-  }
+      const revisedError = new Error(`Bad rpc response: ${message}`)
+      revisedError.hint = safeString`Bad rpc response: ${errorMessageToSafeHint(message)}`
 
-  async isContract(address) {
-    const code = await this.getCode(address)
-    return code.length > 2
-  }
-
-  buildRequest({ method, params = [] }) {
-    return { jsonrpc: '2.0', id: this.id++, method, params }
-  }
+      const traceId = response?.__traceId
+      if (traceId) {
+        revisedError.traceId = traceId
+      }
 
-  balanceOfRequest(address, tokenAddress, tag = 'latest') {
-    const contract = SolidityContract.simpleErc20(tokenAddress)
-    const callData = contract.balanceOf.build(address)
-    const data = {
-      data: bufferToHex(callData),
-      to: tokenAddress,
+      throw revisedError
     }
-    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) {
-    return this.buildRequest({ method: 'eth_estimateGas', params: [data] })
-  }
-
-  sendRawTransactionRequest(data) {
-    const hex = data.startsWith('0x') ? data : '0x' + data
-    return this.buildRequest({ method: 'eth_sendRawTransaction', params: [hex] })
-  }
-
-  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' })
-  }
-
-  getBlockByNumberRequest(numberHex, isFullTxs = false) {
-    return this.buildRequest({ method: 'eth_getBlockByNumber', params: [numberHex, isFullTxs] })
-  }
-
-  simulateRawTransactionRequest(rawTx, applyPending = true) {
-    const replaced = rawTx.replace('0x', '')
-    return this.buildRequest({
-      method: 'debug_simulateRawTransaction',
-      params: [replaced, applyPending],
-    })
-  }
 
-  async balanceOf(address, tokenAddress, tag = 'latest') {
-    const request = this.balanceOfRequest(address, tokenAddress, tag)
-    const result = await this.sendRequest(request)
-    const balance = fromHexToString(result)
-    return {
-      confirmed: {
-        [tokenAddress]: balance,
-      },
-    }
-  }
-
-  async getBalance(...params) {
-    const request = this.getBalanceRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getBalanceProxied(...params) {
-    return this.getBalance(...params)
-  }
-
-  async gasPrice(...params) {
-    const request = this.gasPriceRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  // for fee monitor
-  getGasPrice = this.gasPrice
-
-  async getLatestBlock() {
-    const request = this.buildRequest({
-      method: 'eth_getBlockByNumber',
-      params: ['latest', false],
-    })
-    return this.sendRequest(request)
-  }
-
-  async getBaseFeePerGas() {
-    const response = await this.getLatestBlock()
-    if (response.baseFeePerGas) {
-      return fromHexToString(response.baseFeePerGas)
-    }
-  }
-
-  async estimateGas(...params) {
-    const request = this.estimateGasRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async sendRawTransaction(...params) {
-    const request = this.sendRawTransactionRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getCode(...params) {
-    const request = this.getCodeRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getStorageAt(...params) {
-    const request = this.getStorageAtRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getTransactionCount(...params) {
-    const request = this.getTransactionCountRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getTransactionByHash(...params) {
-    const request = this.getTransactionByHashRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getTransactionReceipt(...params) {
-    const request = this.getTransactionReceiptRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async ethCall(...params) {
-    const request = this.ethCallRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async blockNumber(...params) {
-    const request = this.blockNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async getBlockByNumber(...params) {
-    const request = this.getBlockByNumberRequest(...params)
-    return this.sendRequest(request)
-  }
-
-  async simulateRawTransaction(...params) {
-    const request = this.simulateRawTransactionRequest(...params)
-    return this.sendRequest(request)
+    return result
   }
 
   stop() {

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

@@ -1,11 +1,13 @@
-import ms from 'ms'
-import createWebSocket from './ws'
+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 { bufferToHex } from '@exodus/ethereumjs-util'
-import { randomUUID } from '@exodus/crypto/randomUUID'
-import { fromHexToString } from '../number-utils'
+import ms from 'ms'
+
+import { fromHexToString } from '../number-utils.js'
+import { getFallbackGasPriceEstimation } from './utils.js'
+import createWebSocket from './ws.js'
 
 const RETRY_DELAYS = ['10s']
 
@@ -29,7 +31,7 @@ export function create(defaultURL, ensAssetName) {
       )
     } catch (err) {
       let nerr = err
-      if (err.response && err.response.status === 500) {
+      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+\): /, '')
@@ -63,9 +65,7 @@ export function create(defaultURL, ensAssetName) {
     },
 
     stop() {
-      if (ws.isCreated()) {
-        ws.close()
-      }
+      ws.close()
     },
 
     ws,
@@ -121,6 +121,10 @@ export function create(defaultURL, ensAssetName) {
       return requestWithRetry('proxy', { method: 'eth_gasPrice' })
     },
 
+    async getGasPriceEstimation() {
+      return getFallbackGasPriceEstimation({ server: this })
+    },
+
     // for fee monitor
     async getGasPrice() {
       return requestWithRetry('proxy', { method: 'eth_gasPrice' })
@@ -163,8 +167,13 @@ export function create(defaultURL, ensAssetName) {
     },
 
     async sendRawTransaction(data) {
-      const hex = data.startsWith('0x') ? data : '0x' + data
-      return requestWithRetry('proxy', { method: 'eth_sendRawTransaction', hex })
+      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') {
@@ -254,11 +263,11 @@ export function create(defaultURL, ensAssetName) {
     },
 
     async proxyToCoinNode(requestData) {
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.jsonrpc) requestData.jsonrpc = '2.0'
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.id) requestData.id = randomUUID()
-      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      // eslint-disable-next-line @exodus/hydra/no-param-reassign-prop-only
       if (!requestData.params) requestData.params = []
 
       return request('proxy', requestData, { version: 'v2', method: 'post' })