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

package/src/eip7702-whitelist.js

@@ -0,0 +1,62 @@
+const ADDRESS_REGEX = /^0x[\dA-Fa-f]{40}$/
+
+const isValidWhitelistEntry = (entry) =>
+  typeof entry?.address === 'string' &&
+  ADDRESS_REGEX.test(entry.address) &&
+  typeof entry.name === 'string' &&
+  entry.name.length > 0
+
+export const isValidEip7702Whitelist = (whitelist) =>
+  Array.isArray(whitelist) && whitelist.every((entry) => isValidWhitelistEntry(entry))
+
+/**
+ * Mutable holder for the EIP-7702 delegation whitelist, shared between the
+ * history monitors, security checks and the asset itself. The whitelist data
+ * comes exclusively from remote config; plugins pass `eip7702Supported: []`
+ * as the chain-level feature flag, and the list stays empty until remote
+ * config delivers it. Only chains created with an array accept updates.
+ *
+ * @param {Array<{address: string, name: string}>} [defaultWhitelist] - The
+ *   in-code value, `[]` for supported chains. A non-array means the chain
+ *   does not support EIP-7702.
+ */
+export const createEip7702Whitelist = (defaultWhitelist) => {
+  const supported = Array.isArray(defaultWhitelist)
+  // The array identity is stable across updates (mutated in place), so
+  // consumers holding a reference (e.g. asset.eip7702Supported, which gets
+  // spread-copied into the wallet's asset registry) observe updates too.
+  const current = supported
+    ? defaultWhitelist.map(({ address, name }) => ({ address, name }))
+    : undefined
+
+  return {
+    isSupported: () => supported,
+    get: () => current,
+    /**
+     * Replaces the whitelist with the remote-config value. Returns whether the
+     * update was applied. Invalid payloads and updates on chains without
+     * EIP-7702 support are ignored, keeping the last known good whitelist.
+     */
+    update: (remoteWhitelist) => {
+      if (!supported) return false
+      if (!isValidEip7702Whitelist(remoteWhitelist)) return false
+
+      current.length = 0
+      current.push(...remoteWhitelist.map(({ address, name }) => ({ address, name })))
+      return true
+    },
+  }
+}
+
+/**
+ * Applies the `eip7702Whitelist` field of a per-asset remote config payload,
+ * as delivered to the monitors through `monitor.setServer(remoteConfig)`.
+ */
+export const applyRemoteConfigEip7702Whitelist = ({ eip7702Whitelist, remoteConfig, logger }) => {
+  const remoteWhitelist = remoteConfig?.eip7702Whitelist
+  if (remoteWhitelist === undefined) return
+
+  if (!eip7702Whitelist.update(remoteWhitelist)) {
+    logger?.warn('ignoring invalid eip7702Whitelist from remote config')
+  }
+}

package/src/ens/index.js

@@ -1,9 +1,11 @@
-import SolidityContract from '@exodus/solidity-contract'
-import { toUnicode } from 'idna-uts46-hx'
-import { keccak256 } from 'js-sha3'
+import { hashSync } from '@exodus/crypto/hash'
 import { ABI } from '@exodus/ethereum-lib'
+import SolidityContract from '@exodus/solidity-contract'
+import idna from 'idna-uts46-hx'
+
+import ENS_REGISTRY_ADDRESSES from './addresses.js'
 
-import ENS_REGISTRY_ADDRESSES from './addresses'
+const { toUnicode } = idna
 
 const registry = new SolidityContract(ABI.ensRegistry)
 const resolver = new SolidityContract(ABI.ensResolver)
@@ -17,24 +19,16 @@ function namehash(inputName) {
   // Implementation based on @ensdomains/eth-ens-namehash package
 
   // Reject empty names:
-  var node = ''
-  var i
-  for (i = 0; i < 32; i++) {
-    node += '00'
-  }
-
-  var name = normalize(inputName)
+  let node = Buffer.alloc(32)
 
+  const name = normalize(inputName)
   if (name) {
-    var labels = name.split('.')
-
-    for (i = labels.length - 1; i >= 0; i--) {
-      var labelSha = keccak256(labels[i])
-      node = keccak256(Buffer.from(node + labelSha, 'hex'))
+    for (const label of name.split('.').reverse()) {
+      node = hashSync('keccak256', [node, hashSync('keccak256', label, 'uint8')], 'buffer')
     }
   }
 
-  return '0x' + node
+  return '0x' + node.toString('hex')
 }
 
 // ENS only available on mainnet atm
@@ -70,4 +64,5 @@ const resolveEnsAddress = async (address, server) => {
   return resolver.decodeOutput({ data, method: 'name' })[0]
 }
 
+// This doesn't seem to be used anywhere.
 export { resolveEnsAddress, resolveEnsName }

package/src/error-wrapper.js

@@ -0,0 +1,383 @@
+import { safeString } from '@exodus/safe-string'
+
+// Error types for categorizing EVM errors
+export const EVM_ERROR_TYPES = {
+  NODE_STATE_READ: safeString`NODE_STATE_READ`, // RPC-level read operations
+  CONTRACT_CALL: safeString`CONTRACT_CALL`, // Smart contract calls (eth_call, estimateGas)
+  BROADCAST: safeString`BROADCAST`, // Transaction broadcast errors (includes reverts)
+  PREFLIGHT_VALIDATION: safeString`PREFLIGHT_VALIDATION`, // Logic/state validation before contract gasEstimation & broadcast
+}
+
+// Operation-specific reasons
+export const EVM_ERROR_REASONS = {
+  // RPC-level read operations
+  balanceFetchFailed: {
+    reason: safeString`balance fetch failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  nonceFetchFailed: {
+    reason: safeString`nonce fetch failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getTransactionByHashFailed: {
+    reason: safeString`get transaction by hash failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getCodeFailed: {
+    reason: safeString`get code failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getGasPriceFailed: {
+    reason: safeString`get gas price failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+  getBaseFeePerGasFailed: {
+    reason: safeString`get base fee per gas failed`,
+    type: EVM_ERROR_TYPES.NODE_STATE_READ,
+  },
+
+  // Generic smart contract call failure.
+  ethCallFailed: {
+    reason: safeString`eth call failed`,
+    type: EVM_ERROR_TYPES.CONTRACT_CALL,
+  },
+  ethCallErc20Failed: {
+    reason: safeString`eth call erc20 failed`,
+    type: EVM_ERROR_TYPES.CONTRACT_CALL,
+  },
+
+  // Gas Usage Simulation (checks contract reverts)
+  fetchGasLimitFailed: {
+    reason: safeString`fetch gas limit failed`,
+    type: EVM_ERROR_TYPES.CONTRACT_CALL,
+  },
+
+  // Write operations (checks sender account state/ability to transact)
+  // Generic failure, no info about a particular smart contract revert.
+  broadcastTxFailed: {
+    reason: safeString`broadcast tx failed`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+
+  // Reversion reasons
+  executionReverted: {
+    reason: safeString`execution reverted`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  invalidOpcode: {
+    reason: safeString`invalid opcode`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  insufficientFundsForGas: {
+    reason: safeString`insufficient funds for gas * price + value`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  alreadyKnown: {
+    reason: safeString`already known`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  nonceTooLow: {
+    reason: safeString`nonce too low`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  insufficientBalance: {
+    reason: safeString`execution reverted: insufficient balance / transfer exceeds balance`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  replacementTransactionUnderpriced: {
+    reason: safeString`replacement transaction underpriced`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  zeroTransfer: {
+    reason: safeString`execution reverted: transfer amount must be greater than zero`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  mathError: {
+    reason: safeString`execution reverted: arithmetic overflow/underflow`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+
+  transactionUnderpriced: {
+    reason: safeString`transaction underpriced`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  nonceTooHigh: {
+    reason: safeString`nonce too high`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  gasPriceBelowMin: {
+    reason: safeString`transaction gas price below minimum`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  insufficientGas: {
+    reason: safeString`insufficient gas`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  futureTransactionReplace: {
+    reason: safeString`future transaction tries to replace pending`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  eip155Required: {
+    reason: safeString`eip-155 replay protection required`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  invalidRlpSerialization: {
+    reason: safeString`invalid rlp serialization`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  transactionTypeNotSupported: {
+    reason: safeString`transaction type not supported`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  delegatedAccountError: {
+    reason: safeString`delegated account error`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+  invalidJumpDestination: {
+    reason: safeString`invalid jump destination`,
+    type: EVM_ERROR_TYPES.BROADCAST,
+  },
+}
+
+// Patterns to normalize (group similar errors together)
+const EVM_NORMALIZATION_PATTERNS = [
+  // Insufficient funds for gas (native currency, not tokens)
+  {
+    pattern: /(insufficient funds for gas \* price \+ value|insufficient funds(?!.*balance))/i,
+    errorInfo: EVM_ERROR_REASONS.insufficientFundsForGas,
+  },
+  // Nonce already used. Two flavors:
+  //   - geth: "nonce too low" / "nonce is too low"
+  //   - Cosmos-EVM / Ethermint AnteHandler (e.g. Cronos):
+  //     "invalid nonce; got X, expected Y: invalid sequence: invalid sequence"
+  //     surfaces from load-balancer node drift (chain ahead of read node).
+  //     The retry path in tx-send.js bumps to max(nodeNonce, triedNonce + 1)
+  //     and re-broadcasts. See exodus-desktop#19535.
+  {
+    pattern: /(\bnonce\b.*\btoo low\b|invalid nonce.*invalid sequence)/i,
+    errorInfo: EVM_ERROR_REASONS.nonceTooLow,
+  },
+  // Comprehensive insufficient balance / transfer exceeds balance pattern (TOKEN balance issues)
+  // Catches: ERC20/BEP20, 0xe450d38c custom error, insufficient balance, balanceNotEnough,
+  // and token-specific "transfer amount exceeds balance" (BaseToken, SaveYourAssets, XVS, Ondo, FLOKI, etc.)
+  {
+    pattern:
+      /(0xe450d38c|insufficient.?balance|balance.?not.?enough|not enough fund|(erc20|bep20):.*transfer amount exceeds balance|\w+:.*transfer amount exceeds balance)/i,
+    errorInfo: EVM_ERROR_REASONS.insufficientBalance,
+  },
+  // Arithmetic overflow/underflow errors (SafeMath, Solidity 0.8+, etc.)
+  {
+    pattern: /(safemath:.*overflow|arithmetic underflow or overflow)/i,
+    errorInfo: EVM_ERROR_REASONS.mathError,
+  },
+  // Transfer amount must be greater than zero (various phrasings)
+  {
+    pattern:
+      /(transfer amount must be greater than zero|amount must be greater than 0|amt must be over than 0|zero_amount|transfer amount must be positive|transfer amount zero)/i,
+    errorInfo: EVM_ERROR_REASONS.zeroTransfer,
+  },
+  // Gas price below network minimum (not mempool competition, but protocol minimum)
+  // "gas price below minimum", "gas tip cap...minimum", "max fee per gas less than block base fee"
+  {
+    pattern:
+      /gas price below minimum|gas tip cap.*minimum|max fee per gas less than block base fee/i,
+    errorInfo: EVM_ERROR_REASONS.gasPriceBelowMin,
+  },
+  // Gas limit errors
+  // "intrinsic gas too low", "insufficient gas", "floor data gas cost" - gas limit below minimum required
+  {
+    pattern: /intrinsic gas too low|insufficient gas|floor data gas cost/i,
+    errorInfo: EVM_ERROR_REASONS.insufficientGas,
+  },
+  // "nonce too high" or "nonce is too high" - tx nonce too far ahead
+  {
+    pattern: /\bnonce\b.*\btoo high\b/i,
+    errorInfo: EVM_ERROR_REASONS.nonceTooHigh,
+  },
+  // Transaction type not supported
+  // "transaction type not supported", "tx type not supported" - chain doesn't support this tx type (e.g., EIP-1559)
+  {
+    pattern: /transaction type not supported|tx type not supported/i,
+    errorInfo: EVM_ERROR_REASONS.transactionTypeNotSupported,
+  },
+  // Invalid jump destination
+  {
+    pattern: /invalid jump destination/i,
+    errorInfo: EVM_ERROR_REASONS.invalidJumpDestination,
+  },
+  // Transaction already in mempool/chain
+  // "already known", "known transaction", "already imported", "already in mempool"
+  {
+    pattern: /already known|known transaction|already imported|already in mempool/i,
+    errorInfo: EVM_ERROR_REASONS.alreadyKnown,
+  },
+  // Replacement transaction underpriced (must come BEFORE "transaction underpriced")
+  {
+    pattern: /replacement transaction underpriced/i,
+    errorInfo: EVM_ERROR_REASONS.replacementTransactionUnderpriced,
+  },
+  // Transaction underpriced (checked after replacement to avoid double match)
+  {
+    pattern: /transaction underpriced/i,
+    errorInfo: EVM_ERROR_REASONS.transactionUnderpriced,
+  },
+  // Replay-protected transactions required (EIP-155 chain ID signing)
+  // "only replay-protected", "replay-protected transaction/tx required", "not replay protected", "invalid chain id"
+  {
+    pattern:
+      /only replay-protected|replay-protected (transaction|tx) required|not replay protected|invalid chain id/i,
+    errorInfo: EVM_ERROR_REASONS.eip155Required,
+  },
+  // Future transaction tries to replace pending (nonce conflict)
+  {
+    pattern: /future transaction.*replace.*pending/i,
+    errorInfo: EVM_ERROR_REASONS.futureTransactionReplace,
+  },
+  // Serialization/signature errors
+  // "rlp:", "invalid rlp", "decode rlp", "invalid sender", "invalid signature", "bad signature"
+  {
+    pattern: /rlp:|invalid rlp|decode rlp|invalid sender|invalid signature|bad signature/i,
+    errorInfo: EVM_ERROR_REASONS.invalidRlpSerialization,
+  },
+  // EIP-7702 delegation errors
+  // "delegated" (but not "delegatecall"), "eip-7702", "eip7702" - account delegation related errors
+  {
+    pattern: /\bdelegated\b(?!\s*call)|eip-?7702/i,
+    errorInfo: EVM_ERROR_REASONS.delegatedAccountError,
+  },
+  // GENERIC CATCH-ALL PATTERNS (must be last)
+  {
+    pattern: /^execution reverted$/i,
+    errorInfo: EVM_ERROR_REASONS.executionReverted,
+  },
+  {
+    pattern: /\binvalid opcode\b/i,
+    errorInfo: EVM_ERROR_REASONS.invalidOpcode,
+  },
+  {
+    pattern: /^execution reverted: 0x$/i,
+    errorInfo: EVM_ERROR_REASONS.executionReverted,
+  },
+  // Final catch-all for any remaining "execution reverted:" messages
+  {
+    pattern: /execution reverted:/i,
+    errorInfo: EVM_ERROR_REASONS.executionReverted,
+  },
+]
+
+// This should be renamed something better
+export function getEvmErrorReason(errorMessage) {
+  for (const { pattern, errorInfo } of EVM_NORMALIZATION_PATTERNS) {
+    if (pattern.test(errorMessage)) {
+      return {
+        reason: errorInfo.reason,
+        type: errorInfo.type,
+        wasNormalized: true,
+        patternUsed: pattern.toString(),
+      }
+    }
+  }
+
+  return null
+}
+
+const MAX_HINT_LENGTH = 100
+// TODO: move this to be a generic error for all assets
+export class EthLikeError extends Error {
+  #hintStack
+
+  /**
+   * Creates an instance of EthLikeError.
+   *
+   * @param {string} message - Standard error message.
+   * @param {Object} errorReasonInfo - Object containing reason and type for the error.
+   * @param {string} errorReasonInfo.reason - A constant indicating the generic failure. Must not contain any sensitive information such as private keys, transaction IDs, or wallet addresses.
+   * @param {string} errorReasonInfo.type - A category for the error (e.g., 'NODE_STATE_READ', 'CONTRACT_CALL', 'BROADCAST').
+   * @param {string} hint - A hint to help the user understand the error. Must not contain any sensitive information such as private keys, transaction IDs, or wallet addresses.
+   * @param {TraceId} [traceId] - Optional TraceId object from HTTP response 'traceparent' header for debugging.
+   * @param {string} [baseAssetName] - Optional base asset name (e.g. 'ethereum', 'bnbsmartchain') for identifying the network.
+   */
+  constructor({ message, errorReasonInfo, hint, traceId, baseAssetName }) {
+    super(message)
+    this.name = safeString`EthLikeError`
+    const filteredHint = this.#extractHint(hint)
+    // Only filtered hints are kept on the stack so that subsequent joins via
+    // `addHint` cannot leak sensitive info or untruncated content.
+    this.#hintStack = filteredHint ? [filteredHint] : []
+    this.reason = errorReasonInfo.reason
+    this.hint = filteredHint
+    this.type = errorReasonInfo.type
+    this.traceId = traceId
+    this.baseAssetName = baseAssetName
+  }
+
+  addHint = (hint) => {
+    const filteredHint = this.#extractHint(hint)
+    if (!filteredHint) {
+      return this
+    }
+
+    this.#hintStack.push(filteredHint)
+    this.hint = this.#hintStack.join(':')
+    return this
+  }
+
+  getContext = () => {
+    return {
+      reason: this.reason,
+      type: this.type,
+      traceId: this.traceId,
+      baseAssetName: this.baseAssetName,
+    }
+  }
+
+  // NOTE: a class method for now, if we move this to be a generic error for all assets, each asset will have its own implementation
+  #extractHint = (hint) => {
+    if (!hint) return ''
+
+    // Define regex patterns for sensitive information
+    const sensitivePatterns = [
+      /(?:0x)?[\dA-Fa-f]{20,}/g, // Pattern for hex values of 20 or more characters
+      /(?:[A-Za-z]{3,20}\s+){11}[A-Za-z]{3,20}/g, // Pattern for 12-word phrases
+      /[1-9A-HJ-NP-Za-km-z]{50,}/g, // Pattern for base58 strings of 50 or more characters
+      /(?:[\d+/A-Za-z]{4}){3,}(?:[\d+/A-Za-z]{2}==|[\d+/A-Za-z]{3}=|[\d+/A-Za-z]{4})/g, // Pattern for base64 strings of 12 or more characters
+    ]
+
+    let filteredHint = hint
+
+    // Check for sensitive information
+    const containsSensitiveInfo = sensitivePatterns.some((pattern) => pattern.test(filteredHint))
+
+    if (containsSensitiveInfo) {
+      console.warn('Hint contains sensitive information and will be ignored.')
+      return ''
+    }
+
+    // Limit length to 100 characters
+    if (filteredHint.length > MAX_HINT_LENGTH) {
+      filteredHint = filteredHint.slice(0, MAX_HINT_LENGTH - 3) + '...'
+    }
+
+    return filteredHint
+  }
+}
+
+export const withErrorReason = async ({ promise, errorReasonInfo, hint, baseAssetName }) => {
+  try {
+    return await promise
+  } catch (err) {
+    if (err instanceof EthLikeError) {
+      // ignore errorReason and add hint to stack
+      err.addHint(hint)
+      throw err
+    }
+
+    throw new EthLikeError({
+      message: err.message,
+      errorReasonInfo,
+      hint,
+      traceId: err.traceId,
+      baseAssetName,
+    })
+  }
+}