@exodus/ethereum-api 9.0.0-alpha.2 → 9.0.0

package/src/tx-type/index.js

@@ -0,0 +1,280 @@
+import NumberUnit from '@exodus/currency'
+import { assertValidTxValue, isEthereumLikeToken } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import assert from 'minimalistic-assert'
+
+import { isContractAddressCached } from '../eth-like-util.js'
+
+export const TX_TYPE_TRANSFER = 'transfer'
+export const TX_TYPE_CREATE_CONTRACT = 'create-contract'
+
+const VALID_TX_TYPES = new Set([TX_TYPE_TRANSFER, TX_TYPE_CREATE_CONTRACT])
+
+export const isValidTxType = (txType) => VALID_TX_TYPES.has(txType)
+
+// TODO: Remove this.
+// HACK: If a recipient address is not defined, we usually fall back to
+//       default address so gas estimation can still complete successfully
+//       without knowledge of which accounts are involved.
+//
+//       However, we must be careful to select addresses which are unlikely
+//       to have existing obligations, such as popular dead addresses or the
+//       reserved addresses of precompiles, since these can influence gas
+//       estimation.
+//
+//       Here, we use an address which is mostly all `1`s to make sure we can
+//       exaggerate the worst-case calldata cost (which is priced per high bit)
+//       whilst being unlikely to have any token balances.
+//
+//       Unfortunately, we can't use `0xffffffffffffffffffffffffffffffffffffffff`,
+//       since this address is a whale.
+export const ARBITRARY_ADDRESS = '0xfffFfFfFfFfFFFFFfeFfFFFffFffFFFFfFFFFFFF'.toLowerCase()
+
+export const assertCriticalTxAttributes = (criticalTxAttributes) => {
+  const { amount, toAddress, txInput, txToAddress, txType, txValue } = criticalTxAttributes
+
+  assert(amount instanceof NumberUnit, 'expected NumberUnit amount')
+  assert(
+    typeof txInput === 'string' && txInput.startsWith('0x'),
+    'expected hexadecimal string txInput'
+  )
+  assert(isValidTxType(txType), 'expected valid txType')
+  assert(txValue instanceof NumberUnit, 'expected NumberUnit txValue')
+
+  if (txType === TX_TYPE_CREATE_CONTRACT) {
+    assert(toAddress === null, 'expected null toAddress')
+    assert(txToAddress === null, 'expected null txToAddress')
+    assert(txInput !== '0x', 'expected non-empty txInput for contract creation')
+  } else {
+    assert(typeof toAddress === 'string', 'expected string toAddress')
+    assert(typeof txToAddress === 'string', 'expected string txToAddress')
+  }
+
+  return criticalTxAttributes
+}
+
+export const assertTxAttributes = (txAttributes) => {
+  // TODO: Note that the distinction between "critical" and "non-critical"
+  //       only exists to satisfy `fetchGasLimit` needing to know some props.
+  //       Once we encapsulate `gasLimit`, all properties will be critical.
+  const {
+    /* critical */
+    amount,
+    toAddress,
+    txInput,
+    txToAddress,
+    txType,
+    txValue,
+    /* non-critical */
+    fromAddress,
+    nonce,
+    isContractTxToAddress,
+  } = txAttributes
+
+  assertCriticalTxAttributes({ amount, toAddress, txInput, txToAddress, txType, txValue })
+
+  assert(typeof fromAddress === 'string', 'expected fromAddress')
+  assert(Number.isInteger(nonce), 'expected integer nonce')
+  assert(typeof isContractTxToAddress === 'boolean', 'expected boolean isContractTxToAddress')
+
+  return txAttributes
+}
+
+const createResolvedTxAttributes = async ({
+  amount,
+  asset,
+  fromAddress,
+  nonce,
+  toAddress,
+  txInput,
+  txToAddress,
+  txValue,
+  txType,
+}) =>
+  assertTxAttributes({
+    amount,
+    fromAddress,
+    nonce,
+    toAddress,
+    txInput,
+    txToAddress,
+    txValue,
+    txType,
+    isContractTxToAddress:
+      Boolean(txToAddress) && (await isContractAddressCached({ asset, address: txToAddress })),
+  })
+
+export const resolveTxFromAddress = async ({
+  asset,
+  assetClientInterface,
+  fromAddress: providedFromAddress,
+  walletAccount,
+}) => {
+  assert(asset, 'expected asset')
+  assert(assetClientInterface, 'expected assetClientInterface')
+  assert(walletAccount, 'expected walletAccount')
+
+  if (providedFromAddress) return providedFromAddress
+
+  return assetClientInterface.getReceiveAddress({
+    assetName: asset.baseAsset.name,
+    walletAccount,
+  })
+}
+
+export const resolveTxNonce = async ({
+  asset,
+  fromAddress,
+  nonce: providedNonce,
+  walletAccount,
+}) => {
+  assert(asset, 'expected asset')
+  assert(typeof fromAddress === 'string', 'expected string fromAddress')
+  assert(walletAccount, 'expected walletAccount')
+
+  if (Number.isInteger(providedNonce)) return providedNonce
+
+  return asset.baseAsset.getNonce({ asset, fromAddress, walletAccount })
+}
+
+const resolveTxInput = ({ asset, toAddress, amount, txInput: providedTxInput }) => {
+  assert(asset, 'expected asset')
+  assert(typeof toAddress === 'string', 'expected string toAddress')
+  assert(amount instanceof NumberUnit, 'expected NumberUnit amount')
+
+  if (providedTxInput) return bufferToHex(providedTxInput)
+
+  if (!isEthereumLikeToken(asset)) return '0x'
+
+  return bufferToHex(asset.contract.transfer.build(toAddress.toLowerCase(), amount?.toBaseString()))
+}
+
+export const resolveCriticalTxAttributes = ({
+  asset,
+  amount: providedAmount,
+  toAddress: providedToAddress,
+  txToAddress: providedTxToAddress,
+  txInput: providedTxInput,
+  txValue: providedTxValue,
+  txType,
+}) => {
+  assert(asset, 'expected asset')
+  assert(isValidTxType(txType), 'expected valid txType')
+
+  const amount = providedAmount ?? asset.currency.ZERO
+  assert(amount instanceof NumberUnit, 'expected providedAmount')
+
+  const txValue = assertValidTxValue({ asset, amount, txValue: providedTxValue })
+
+  if (txType === TX_TYPE_CREATE_CONTRACT) {
+    assert(asset.name === asset.baseAsset.name, 'must use baseAsset for contract deployments')
+    assert(!providedToAddress, 'toAddress must be falsy when creating a contract')
+    assert(!providedTxToAddress, 'txToAddress must be falsy when creating a contract')
+
+    return assertCriticalTxAttributes({
+      amount,
+      toAddress: null,
+      txInput: providedTxInput,
+      txToAddress: null,
+      txType,
+      txValue,
+    })
+  }
+
+  assert(txType === TX_TYPE_TRANSFER, 'expected TX_TYPE_TRANSFER')
+
+  // NOTE: As a helper, if the `toAddress` is omitted, we
+  //       will automatically assume the recipient of the
+  //       transaction value to be the `providedTxToAddress`.
+  //
+  //       This means we'll assume the high-level recipient
+  //       of the assets transferred will be the
+  //       `providedTxToAddress`, as opposed to another account
+  //       which would be credited as a side effect.
+  //
+  // HACK: If a `toAddress` hasn't been defined, then we
+  //       fall back to the `ARBITRARY_ADDRESS`. Note that
+  //       this should only be used to help determine the
+  //       fee of a transaction where we don't yet know the
+  //       intended recipient. Attempts to send to this
+  //       sentinel address will ultimately `throw`.
+  const toAddress = providedToAddress || providedTxToAddress || ARBITRARY_ADDRESS
+  const txInput = resolveTxInput({ amount, asset, txInput: providedTxInput, toAddress })
+
+  const baseProps = {
+    amount,
+    toAddress,
+    txInput,
+    txType,
+    txValue,
+  }
+
+  // When CEX swapping a main asset, the exchange may provide a txInput and an address. Use this address as the tx 'to' address.
+  // When DEX swapping a main asset, the exchange provides a txInput and a DEX address. Use the DEX address as the tx 'to' address.
+  // When sending a main asset, the transaction (tx) 'to' address is the receiver's address. No tx input is provided.
+  if (!isEthereumLikeToken(asset)) {
+    return assertCriticalTxAttributes({
+      ...baseProps,
+      txToAddress: providedTxToAddress || toAddress,
+    })
+  }
+
+  if (providedTxInput) {
+    // When CEX swapping a token, the exchange may provide a txInput but not an address. In this case, the tx 'to' address is the token address.
+    // When DEX swapping a token, the exchange provides a txInput and a DEX address. Use the DEX address as the tx 'to' address.
+    const txToAddress = providedTxToAddress || providedToAddress || asset.contract?.address
+    return assertCriticalTxAttributes({ ...baseProps, txToAddress })
+  }
+
+  // When sending a token, the tx 'to' address is the asset.contract?.address. No tx input is provided; it's resolved locally.
+  const txToAddress = asset.contract?.address
+  return assertCriticalTxAttributes({ ...baseProps, txToAddress })
+}
+
+// Normalizes the properties of transactions that can
+// vary depending upon the `txType` and `asset` to
+// ensure these evaluate consistently.
+export const resolveTxAttributesByTxType = async ({
+  asset,
+  assetClientInterface,
+  amount: providedAmount,
+  fromAddress: providedFromAddress,
+  nonce: providedNonce,
+  txInput: providedTxInput,
+  txToAddress: providedTxToAddress,
+  toAddress: providedToAddress,
+  txValue: providedTxValue,
+  txType,
+  walletAccount,
+}) => {
+  assert(isValidTxType(txType), 'expected valid txType')
+
+  const fromAddress = await resolveTxFromAddress({
+    asset,
+    assetClientInterface,
+    fromAddress: providedFromAddress,
+    walletAccount,
+  })
+
+  const nonce = await resolveTxNonce({
+    asset,
+    fromAddress,
+    nonce: providedNonce,
+    walletAccount,
+  })
+
+  return createResolvedTxAttributes({
+    asset,
+    fromAddress,
+    nonce,
+    ...resolveCriticalTxAttributes({
+      asset,
+      amount: providedAmount,
+      toAddress: providedToAddress,
+      txInput: providedTxInput,
+      txToAddress: providedTxToAddress,
+      txValue: providedTxValue,
+      txType,
+    }),
+  })
+}

package/src/watch-tx.js

@@ -0,0 +1,36 @@
+import delay from 'delay'
+import ms from 'ms'
+
+const WATCH_TX_DELAY = ms('5s')
+const WATCH_TX_TIMEOUT = ms('5m')
+
+// this could go to asset-lib
+export const createWatchTx =
+  ({
+    walletAccount,
+    getTxLog,
+    baseAsset,
+    watchTxDelay = WATCH_TX_DELAY,
+    watchTxTimeout = WATCH_TX_TIMEOUT,
+  }) =>
+  async (txId) => {
+    const start = Date.now()
+    let txConfirmed = false
+    let hasTimedOut = false
+
+    while (!hasTimedOut && !txConfirmed) {
+      await delay(watchTxDelay)
+      const baseAssetTxLog = await getTxLog({
+        assetName: baseAsset.name,
+        walletAccount,
+      })
+      txConfirmed = baseAssetTxLog.get(txId)?.confirmed
+      hasTimedOut = Date.now() - start > watchTxTimeout
+    }
+
+    if (!txConfirmed) {
+      throw new Error("The transaction wasn't confirmed in time.")
+    }
+
+    return { txId }
+  }

package/src/web3/createSimulateMessage.js

@@ -1,8 +1,9 @@
-import { createSimulateMessage as createSimulateEVMMessage } from '@exodus/web3-ethereum-utils'
 import assert from 'minimalistic-assert'
 
+import { createSimulateMessage as createSimulateEVMMessage } from '../simulation/create-simulate-message.js'
+
 export const createSimulateMessage = ({ asset }) => {
-  assert('asset', '"asset" should be passed.')
+  assert(asset, '"asset" should be passed.')
 
   const simulateEVMMessage = createSimulateEVMMessage()
 

package/src/web3/createSimulateTransactions.js

@@ -0,0 +1,11 @@
+import assert from 'minimalistic-assert'
+
+import { simulateTransactions as simulateEthereumTransactions } from '../simulation/simulate-transactions.js'
+
+export const createSimulateTransactions = ({ asset }) => {
+  assert(asset, '"asset" should be passed.')
+
+  return function simulateTransaction({ transactions, ...restParameters }) {
+    return simulateEthereumTransactions({ asset, transactions, ...restParameters })
+  }
+}

package/src/web3/index.js

@@ -1,7 +1,9 @@
-import { createSimulateMessage } from './createSimulateMessage'
+import { createSimulateMessage } from './createSimulateMessage.js'
+import { createSimulateTransactions } from './createSimulateTransactions.js'
 
 export const createWeb3API = (deps) => {
   return {
     simulateMessage: createSimulateMessage(deps),
+    simulateTransactions: createSimulateTransactions(deps),
   }
 }

package/src/etherscan/account.js

@@ -1,49 +0,0 @@
-import assert from 'minimalistic-assert'
-import request from './request'
-
-const isValidResponseCheck = (x) =>
-  (x.status === '1' && x.message === 'OK') || x.message === 'No transactions found'
-const _request = async (...args) => request(isValidResponseCheck, 'account', ...args)
-
-export async function fetchBalance(address) {
-  const balance = await _request('balance', { address })
-
-  const isValid = /^\d+$/.test(balance)
-  if (!isValid) throw new RangeError(`Invalid balance: ${balance}`)
-
-  return balance
-}
-
-export async function fetchTxlist(address, options) {
-  const params = { startblock: 0, endblock: 'latest', ...options, address }
-  const txlist = await _request('txlist', params)
-
-  // simple check
-  assert(Array.isArray(txlist), `Invalid transactions: ${txlist}`)
-
-  return txlist
-}
-
-export async function fetchTxlistinternal(address, options) {
-  const params = { startblock: 0, endblock: 'latest', ...options, address }
-  const txlist = await _request('txlistinternal', params)
-
-  // simple check
-  assert(Array.isArray(txlist), `Invalid transactions: ${txlist}`)
-
-  return txlist
-}
-
-export async function tokenBalance(token, address) {
-  const params = {
-    [token.length === 42 ? 'contractaddress' : 'tokenname']: token,
-    address,
-    tag: 'latest',
-  }
-  const balance = await _request('tokenbalance', params)
-
-  const isValid = /^\d+$/.test(balance)
-  if (!isValid) throw new RangeError(`Invalid balance: ${balance}`)
-
-  return balance
-}

package/src/etherscan/index.js

@@ -1,28 +0,0 @@
-import createWebSocket from './ws'
-
-export const ETHERSCAN_WS_URL = 'wss://socket.etherscan.io/wshandler'
-
-export const ws = createWebSocket(ETHERSCAN_WS_URL)
-
-export function filterTxsSent(addr, etherscanTxs) {
-  return etherscanTxs.filter((tx) => tx.from.toLowerCase() === addr.toLowerCase())
-}
-
-export function filterTxsReceived(addr, etherscanTxs) {
-  return etherscanTxs.filter((tx) => tx.to.toLowerCase() === addr.toLowerCase())
-}
-
-export { fetchBalance, fetchTxlistinternal, fetchTxlist, tokenBalance } from './account'
-export {
-  sendRawTransaction,
-  getTransactionCount,
-  estimateGas,
-  getTransactionReceipt,
-  getCode,
-  ethCall,
-  gasPrice,
-} from './proxy'
-
-export { setEtherscanApiKey as setApiKey } from './request'
-
-export { getLogs } from './logs'

package/src/etherscan/logs.js

@@ -1,16 +0,0 @@
-import assert from 'minimalistic-assert'
-import request from './request'
-
-const isValidResponseCheck = (x) =>
-  (x.status === '1' && x.message === 'OK') || x.message === 'No records found'
-const _request = async (...args) => request(isValidResponseCheck, 'logs', ...args)
-
-export async function getLogs(address, fromBlock, toBlock, options) {
-  const params = { ...options, address, fromBlock, toBlock }
-  const events = await _request('getLogs', params)
-
-  // simple check
-  assert(Array.isArray(events), `Invalid transactions: ${events}`)
-
-  return events
-}

package/src/etherscan/proxy.js

@@ -1,47 +0,0 @@
-import request from './request'
-
-const isValidResponseCheck = (x) => x.result !== undefined
-const _request = async (...args) => request(isValidResponseCheck, 'proxy', ...args)
-
-export async function sendRawTransaction(data) {
-  const txhash = await _request('eth_sendRawTransaction', { hex: '0x' + data })
-
-  const isValidTxHash = /^0x[\dA-Fa-f]{64}$/.test(txhash)
-  if (!isValidTxHash) throw new Error(`Invalid tx hash: ${txhash}`)
-
-  return txhash.slice(2)
-}
-
-export async function getTransactionCount(address, tag = 'latest') {
-  return _request('eth_getTransactionCount', { address, tag })
-}
-
-export async function getTransactionReceipt(txhash) {
-  return _request('eth_getTransactionReceipt', { txhash })
-}
-
-export async function estimateGas(data) {
-  return _request('eth_estimateGas', data)
-}
-
-export async function getCode(address) {
-  const code = await _request('eth_getCode', { address })
-
-  const isValidCode = /^0x[\dA-Fa-f]*$/.test(code) && code.length % 2 === 0
-  if (!isValidCode) throw new Error(`Invalid address code: ${code}`)
-
-  return code
-}
-
-export async function gasPrice() {
-  const price = await _request('eth_gasPrice')
-
-  const isValidPrice = /^0x[\dA-Fa-f]+$/.test(price)
-  if (!isValidPrice) throw new Error(`Invalid price: ${price}`)
-
-  return price
-}
-
-export async function ethCall(data) {
-  return _request('eth_call', data)
-}

package/src/etherscan/request.js

@@ -1,26 +0,0 @@
-import ms from 'ms'
-import makeConcurrent from 'make-concurrent'
-import fetchival from '@exodus/fetch/experimental/fetchival'
-
-const ETHERSCAN_API_URL = 'https://api.etherscan.io/api'
-const DEFAULT_ETHERSCAN_API_KEY = 'XM3VGRSNW1TMSIR14I9MVFP15X74GNHTRI'
-
-let etherscanApiKey = DEFAULT_ETHERSCAN_API_KEY
-
-export function setEtherscanApiKey(apiKey) {
-  etherscanApiKey = apiKey || DEFAULT_ETHERSCAN_API_KEY
-}
-
-export default makeConcurrent(
-  async function (isValidResponseCheck, module, action, params = {}) {
-    const data = await fetchival(new URL(ETHERSCAN_API_URL), { timeout: ms('15s') }).get({
-      ...params,
-      module,
-      action,
-      apiKey: etherscanApiKey,
-    })
-    if (!isValidResponseCheck(data)) throw new Error(`Invalid response: ${JSON.stringify(data)}`)
-    return data.result
-  },
-  { concurrency: 3 }
-)

package/src/etherscan/ws.js

@@ -1,88 +0,0 @@
-import EventEmitter from 'events/' // '/' forces it to use the module from node_modules
-import ms from 'ms'
-import WebSocket from '../websocket'
-
-const RECONNECT_INTERVAL = ms('10s')
-const PING_INTERVAL = ms('20s')
-
-export default function createWebSocket(url) {
-  const addresses = new Set()
-  const events = new EventEmitter().setMaxListeners(20)
-  const pingMessage = JSON.stringify({ event: 'ping' })
-  let ws
-  let wsOpened = false
-  let opened = false
-  let openTimeoutId
-  let pingIntervalId
-
-  function subscribeAddress(address) {
-    const data = JSON.stringify({ event: 'txlist', address })
-    ws.send(data)
-  }
-
-  function onMessage(data) {
-    data = JSON.parse(data)
-    switch (data.event) {
-      case 'txlist':
-        for (const tx of data.result) events.emit(`address-${data.address}`, tx)
-        break
-
-      case 'subscribe-txlist':
-        const match = data.message.toLowerCase().match(/0x[\da-f]{40}/)
-        if (match && data.status === '1') events.emit(`address-${match[0]}-subscribed`)
-        else ws.close()
-        break
-    }
-  }
-
-  function isOpened() {
-    return wsOpened
-  }
-
-  function open() {
-    opened = true
-    clearTimeout(openTimeoutId)
-    if (ws) return
-
-    ws = new WebSocket(url)
-
-    ws.on('message', (data) => {
-      try {
-        onMessage(data)
-      } catch {}
-    })
-    ws.once('open', () => {
-      for (const address of addresses.values()) subscribeAddress(address)
-      pingIntervalId = setInterval(() => ws && ws.send(pingMessage), PING_INTERVAL)
-      wsOpened = true
-      events.emit('open')
-    })
-    ws.once('close', () => {
-      ws = null
-      clearInterval(pingIntervalId)
-      if (opened) openTimeoutId = setTimeout(open, RECONNECT_INTERVAL)
-      wsOpened = false
-      events.emit('close')
-    })
-  }
-
-  function close() {
-    opened = false
-    clearTimeout(openTimeoutId)
-    if (!ws) return
-
-    ws.close()
-    ws = null
-  }
-
-  function watch(address) {
-    address = address.toLowerCase()
-
-    if (addresses.has(address)) return
-    addresses.add(address)
-
-    if (wsOpened) subscribeAddress(address)
-  }
-
-  return { events, isOpened, open, close, watch }
-}

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

@@ -1,28 +0,0 @@
-import { create } from './api'
-import ClarityServer from './clarity'
-import ApiCoinNodesServer from './api-coin-nodes'
-import assert from 'minimalistic-assert'
-import { serverMap } from './server-map'
-
-function basicCreateEvmServer({ assetName, serverUrl, monitorType }) {
-  assert(assetName, 'assetName is required')
-  assert(serverUrl, 'serverUrl is required')
-  assert(monitorType, 'monitorType is required')
-  switch (monitorType) {
-    case 'no-history':
-      return new ApiCoinNodesServer({ uri: serverUrl })
-    case 'clarity':
-      return new ClarityServer({ baseAssetName: assetName, uri: serverUrl })
-    case 'magnifier':
-      return create(serverUrl, assetName)
-    default:
-      throw new Error(`No server API found for ${assetName} and type ${monitorType}`)
-  }
-}
-
-export function createEvmServer({ assetName, serverUrl, monitorType }) {
-  if (serverMap[assetName]) return serverMap[assetName]
-  const server = basicCreateEvmServer({ assetName, serverUrl, monitorType })
-  serverMap[assetName] = server
-  return server
-}

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

@@ -1,21 +0,0 @@
-// @Deprecated
-export const serverMap = Object.create(null)
-
-export function getServer(asset) {
-  const server = asset.baseAsset.server
-  if (server) {
-    return server
-  }
-
-  // legacy way using the global serverMap
-  return getServerByName(asset.baseAsset.name)
-}
-
-export function getServerByName(baseAssetName) {
-  console.warn(
-    `Asking ${baseAssetName} server by name, please use asset.baseAsset.server or getServer(asset)`
-  )
-  const server = serverMap[baseAssetName]
-  if (!server) throw new Error(`Unsupported base asset ${baseAssetName}`)
-  return server
-}