@exodus/ethereum-api 8.40.0 → 8.41.0-alpha.0

package/src/tx-create.js

@@ -0,0 +1,352 @@
+import { calculateBumpedGasPrice, currency2buffer, isEthereumLikeToken } from '@exodus/ethereum-lib'
+import createEthereumJsTx from '@exodus/ethereum-lib/src/unsigned-tx/create-ethereumjs-tx.js'
+import assert from 'minimalistic-assert'
+
+import * as ErrorWrapper from './error-wrapper.js'
+import { isContractAddressCached } from './eth-like-util.js'
+import { ensureSaneEip1559GasPriceForTipGasPrice } from './fee-utils.js'
+import { ARBITRARY_ADDRESS, fetchGasLimit, resolveDefaultTxInput } from './gas-estimation.js'
+import { getFeeFactoryGasPrices } from './get-fee.js'
+import { getNftArguments } from './nft-utils.js'
+import { resolveNonce } from './tx-send/nonce-utils.js'
+
+async function createUnsignedTxWithFees({
+  asset,
+  chainId,
+  to, // the tx to address, it could be the reciver address for native sending, the token contract, the DEX contract, etc
+  value, // the value of the tx in NU, it can be the value in eth or 0 when calling contracts
+  data, // the data of the tx in hex string, it can be 0x for native sending or the params when sending to a contract
+  gasLimit,
+  eip1559Enabled,
+  gasPrice, // eip 1559: `maxFeePerGas`
+  tipGasPrice, // eip 1559: `maxPriorityPerGas`
+  nonce,
+  bumpTxId,
+  coinAmount, // coinAmount
+  fromAddress, // user's sending address
+  toAddress, // user's receiver address
+}) {
+  assert(asset, 'asset is required')
+  assert(typeof chainId === 'number', 'chainId is required')
+  assert(to, 'to is required')
+  assert(value, 'value is required')
+  assert(data, 'data is required')
+  assert(gasLimit, 'gasLimit is required')
+  assert(gasPrice, 'gasPrice is required')
+  assert(coinAmount, 'coinAmount is required')
+  assert(fromAddress, 'fromAddress is required')
+  assert(toAddress, 'toAddress is required')
+  assert(typeof eip1559Enabled === 'boolean', 'eip1559Enabled is required')
+
+  const ethjsTx = createEthereumJsTx({
+    txData: {
+      nonce,
+      gasPrice: currency2buffer(gasPrice),
+      tipGasPrice: tipGasPrice ? currency2buffer(tipGasPrice) : undefined,
+      gasLimit,
+      to,
+      value: currency2buffer(value),
+      data,
+      chainId,
+    },
+    txMeta: {
+      eip1559Enabled,
+    },
+  })
+  const transactionBuffer = ethjsTx.serialize()
+
+  const baseFee = gasPrice.mul(gasLimit)
+  const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
+    ? await asset.baseAsset.estimateL1DataFee({
+        unsignedTx: { txData: { transactionBuffer, chainId } },
+      })
+    : undefined
+
+  const l1DataFee = optimismL1DataFee
+    ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
+    : asset.baseAsset.currency.ZERO
+
+  const fee = baseFee.add(l1DataFee)
+
+  const unsignedTx = {
+    txData: { transactionBuffer, chainId },
+    txMeta: {
+      bumpTxId,
+      eip1559Enabled,
+      fromAddress,
+      toAddress,
+      amount: coinAmount.toDefaultString({ unit: true }),
+      fee: fee.toDefaultString({ unit: true }),
+    },
+  }
+  return { unsignedTx }
+}
+
+const createBumpUnsignedTx = async ({
+  fromAddress,
+  chainId,
+  asset,
+  bumpTxId,
+  baseAssetTxLog,
+  assetClientInterface,
+  walletAccount,
+  feeData,
+  nonce: providedNonce,
+}) => {
+  const baseAsset = asset.baseAsset
+  const replacedTx = baseAssetTxLog.get(bumpTxId)
+  const assets = await assetClientInterface.getAssetsForNetwork({ baseAssetName: baseAsset.name })
+  if (!replacedTx || !replacedTx.pending) {
+    throw new Error(`Cannot bump transaction ${bumpTxId}: not found or confirmed`)
+  }
+
+  let replacedTokenTx
+  if (replacedTx.tokens.length > 0) {
+    const [tokenAssetName] = replacedTx.tokens
+    const tokenTxSet = await assetClientInterface.getTxLog({
+      assetName: tokenAssetName,
+      walletAccount,
+    })
+    replacedTokenTx = tokenTxSet.get(bumpTxId)
+
+    if (replacedTokenTx) {
+      // Attempt to overwrite the asset to reflect the fact that
+      // we're performing a token transaction.
+      asset = assets[tokenAssetName]
+      if (!asset) {
+        throw new Error(
+          `unable to find ${tokenAssetName} during token bump transaction: asset was not available in assetsForNetwork`
+        )
+      }
+    }
+  }
+
+  const toAddress = (replacedTokenTx || replacedTx).to
+  const isToken = isEthereumLikeToken(asset)
+  const txToAddress = isToken ? asset.contract.address : toAddress
+  const coinAmount = (replacedTokenTx || replacedTx).coinAmount.negate()
+  const gasLimit = replacedTx.data.gasLimit
+
+  const value = isToken ? baseAsset.currency.ZERO : coinAmount
+
+  const {
+    gasPrice: currentGasPrice,
+    baseFeePerGas: currentBaseFee,
+    eip1559Enabled,
+    tipGasPrice: currentTipGasPrice,
+  } = feeData
+  const { bumpedGasPrice, bumpedTipGasPrice } = calculateBumpedGasPrice({
+    baseAsset,
+    tx: replacedTx,
+    currentGasPrice,
+    currentBaseFee,
+    currentTipGasPrice,
+    eip1559Enabled,
+  })
+  const gasPrice = bumpedGasPrice
+  const tipGasPrice = bumpedTipGasPrice
+  const nonce = replacedTx.data.nonce
+  const data = replacedTokenTx
+    ? asset.contract.transfer.build(toAddress.toLowerCase(), coinAmount.toBaseString())
+    : replacedTx.data.data || '0x'
+
+  if (nonce === undefined) {
+    throw new Error(`Cannot bump transaction ${bumpTxId}: data object seems to be corrupted`)
+  }
+
+  // If we have evaluated a bump transaction and the `providedNonce` differs
+  // from the `bumpNonce`, we've encountered a conflict and cannot respect
+  // the caller's request.
+  if (typeof nonce === 'number' && typeof providedNonce === 'number' && nonce !== providedNonce)
+    throw new ErrorWrapper.EthLikeError({
+      message: new Error('incorrect nonce for replacement transaction'),
+      reason: ErrorWrapper.reasons.bumpTxFailed,
+      hint: 'providedNonce',
+    })
+
+  return createUnsignedTxWithFees({
+    asset,
+    chainId,
+    to: txToAddress,
+    value,
+    data,
+    gasLimit,
+    gasPrice,
+    tipGasPrice,
+    nonce,
+    bumpTxId,
+    coinAmount,
+    fromAddress,
+    toAddress,
+    eip1559Enabled,
+  })
+}
+
+export const createTxFactory = ({ chainId, assetClientInterface, useAbsoluteNonce }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(typeof chainId === 'number', 'chainId is required')
+  return async ({
+    asset,
+    walletAccount,
+    feeData,
+    nft, // when sending nfts
+    fromAddress: providedFromAddress, // wallet from address
+    toAddress: providedToAddress, // user's to address, not the token or the dex contract
+    contractAddress: providedContractAddress, // Provided when swapping a token via the DEX contract, not via the token's contract
+    txInput: providedTxInput, // Provided when swapping via a DEX contract
+    gasLimit: providedGasLimit, // Provided by exchange when known
+    amount: providedAmount, // The NU amount to be sent, to be included in the tx value or tx input
+    nonce: providedNonce,
+    tipGasPrice: providedTipGasPrice,
+    gasPrice: providedGasPrice,
+    bip70,
+    isExchange,
+    customFee,
+    isSendAll,
+    bumpTxId,
+    keepTxInput, // @deprecated this flag is used by swaps when swapping a token via DEX. The asset is token but the tx TO address is not the token address. Update swap to use `contractAddress`
+  }) => {
+    assert(asset, 'asset is required')
+    assert(feeData, 'feeData is required')
+    const fromAddress = providedFromAddress || ARBITRARY_ADDRESS
+
+    const baseAssetTxLog = await assetClientInterface.getTxLog({
+      assetName: asset.baseAsset.name,
+      walletAccount,
+    })
+
+    if (bumpTxId) {
+      return createBumpUnsignedTx({
+        chainId,
+        asset,
+        fromAddress,
+        bumpTxId,
+        baseAssetTxLog,
+        assetClientInterface,
+        walletAccount,
+        feeData,
+        nonce: providedNonce,
+      })
+    }
+
+    const toAddress = providedToAddress || ARBITRARY_ADDRESS
+    const {
+      gasPrice: maybeGasPrice,
+      feeData: { tipGasPrice: maybeTipGasPrice, eip1559Enabled },
+    } = getFeeFactoryGasPrices({ customFee, feeData })
+
+    const isToken = isEthereumLikeToken(asset)
+
+    const resolvedGasPrice = providedGasPrice ?? maybeGasPrice
+
+    const txToAddress =
+      providedContractAddress ?? (isToken && !keepTxInput ? asset.contract.address : toAddress)
+
+    const isContractToAddress = await isContractAddressCached({ asset, address: txToAddress })
+
+    // HACK: We cannot ensure the no dust invariant for `isSendAll`
+    //       transactions to contract addresses, since we may be
+    //       performing a raw token transaction and the parameter
+    //       applies to the token and not the native amount.
+    //
+    //       Contracts have nondeterministic gas most of the time
+    //       versus estimations, anyway.
+    const isSendAllBaseAsset = isSendAll && !isToken && !isContractToAddress
+
+    // For native send all transactions, we have to make sure that
+    // the `tipGasPrice` is equal to the `gasPrice`, since this is
+    // effectively like saying that the `maxFeePerGas` is equal
+    // to the `maxPriorityFeePerGas`. We do this so that for a
+    // fixed gas cost transaction, no dust balance should remain,
+    // since any deviation in the underlying `baseFeePerGas` will
+    // result only affect the tip for the miner - no dust remains.
+    const tipGasPrice =
+      providedTipGasPrice ??
+      (eip1559Enabled && isSendAllBaseAsset ? resolvedGasPrice : maybeTipGasPrice)
+
+    const gasPrice = eip1559Enabled
+      ? ensureSaneEip1559GasPriceForTipGasPrice({
+          gasPrice: resolvedGasPrice,
+          tipGasPrice,
+        })
+      : resolvedGasPrice
+
+    const nonce =
+      providedNonce ??
+      (await resolveNonce({
+        asset,
+        fromAddress,
+        txLog: baseAssetTxLog,
+        // For assets where we'll fall back to querying the coin node, we
+        // search for pending transactions. For base assets with history,
+        // we'll fall back to the `TxLog` since this also has a knowledge
+        // of which transactions are currently in pending.
+        tag: 'pending',
+        useAbsoluteNonce,
+      }))
+
+    if (nft) {
+      const {
+        contractAddress: txToAddress,
+        gasLimit,
+        txInput,
+      } = await getNftArguments({
+        asset,
+        nft,
+        fromAddress,
+        toAddress: providedToAddress,
+      })
+
+      const value = asset.baseAsset.currency.ZERO
+
+      return createUnsignedTxWithFees({
+        chainId,
+        asset,
+        to: txToAddress,
+        value,
+        data: txInput,
+        gasLimit,
+        gasPrice,
+        tipGasPrice,
+        nonce,
+        coinAmount: value,
+        fromAddress,
+        toAddress,
+        eip1559Enabled,
+      })
+    }
+
+    const amount = providedAmount ?? asset.currency.ZERO
+
+    const value = isToken ? asset.baseAsset.currency.ZERO : amount
+    const txInput = providedTxInput || resolveDefaultTxInput({ asset, toAddress, amount })
+    const gasLimit =
+      providedGasLimit ??
+      (await fetchGasLimit({
+        asset,
+        feeData,
+        fromAddress: providedFromAddress,
+        toAddress: providedToAddress,
+        txInput: providedTxInput,
+        contractAddress: txToAddress,
+        bip70,
+        amount,
+      }))
+
+    return createUnsignedTxWithFees({
+      asset,
+      chainId,
+      to: txToAddress,
+      value,
+      data: txInput,
+      gasLimit,
+      gasPrice,
+      tipGasPrice,
+      nonce,
+      coinAmount: amount,
+      fromAddress,
+      toAddress,
+      eip1559Enabled,
+    })
+  }
+}

package/src/tx-log/clarity-monitor.js

@@ -1,5 +1,5 @@
 import { BaseMonitor } from '@exodus/asset-lib'
-import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
+import { getAssetAddresses } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 
 import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
@@ -16,10 +16,11 @@ import {
 const { isEmpty } = lodash
 
 export class ClarityMonitor extends BaseMonitor {
-  constructor({ server, config, ...args }) {
+  constructor({ server, config, rpcBalanceAssetNames, ...args }) {
     super(args)
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
     this.server = server
+    this.rpcBalanceAssetNames = rpcBalanceAssetNames
     this.getAllLogItemsByAsset = getAllLogItemsByAsset
     this.deriveDataNeededForTick = getDeriveDataNeededForTick(this.aci)
     this.deriveTransactionsToCheck = getDeriveTransactionsToCheck({
@@ -201,7 +202,7 @@ export class ClarityMonitor extends BaseMonitor {
     const asset = this.asset
     const newAccountState = Object.create(null)
     const balances = await this.getBalances({ tokens, ourWalletAddress })
-    if (isRpcBalanceAsset(asset)) {
+    if (this.rpcBalanceAssetNames.includes(asset.name)) {
       const balance = balances[asset.name]
       newAccountState.balance = asset.currency.baseUnit(balance)
     }
@@ -244,13 +245,13 @@ export class ClarityMonitor extends BaseMonitor {
 
   async getBalances({ tokens, ourWalletAddress }) {
     const batch = Object.create(null)
-    if (isRpcBalanceAsset(this.asset)) {
+    if (this.rpcBalanceAssetNames.includes(this.asset.name)) {
       const request = this.server.getBalanceRequest(ourWalletAddress)
       batch[this.asset.name] = request
     }
 
     for (const token of tokens) {
-      if (isRpcBalanceAsset(token) && token.contract.address) {
+      if (this.rpcBalanceAssetNames.includes(token.name) && token.contract.address) {
         const request = this.server.balanceOfRequest(ourWalletAddress, token.contract.address)
         batch[token.name] = request
       }

package/src/tx-log/ethereum-monitor.js

@@ -1,5 +1,5 @@
 import { BaseMonitor } from '@exodus/asset-lib'
-import { getAssetAddresses, isRpcBalanceAsset } from '@exodus/ethereum-lib'
+import { getAssetAddresses } from '@exodus/ethereum-lib'
 import lodash from 'lodash'
 
 import { executeEthLikeFeeMonitorUpdate } from '../fee-utils.js'
@@ -25,7 +25,7 @@ const { isEmpty } = lodash
 // formatting, and populating-to-state all ETH/ETC/ERC20 transactions.
 
 export class EthereumMonitor extends BaseMonitor {
-  constructor({ server, config, webSocketEnabled = true, ...args }) {
+  constructor({ server, config, rpcBalanceAssetNames, webSocketEnabled = true, ...args }) {
     super(args)
     this.server = server
     this.config = { GAS_PRICE_FROM_WEBSOCKET: true, ...config }
@@ -38,6 +38,7 @@ export class EthereumMonitor extends BaseMonitor {
     this.addHook('after-stop', (...args) => this.afterStop(...args))
     this.subscribedToGasPriceMap = new Map()
     this._webSocketEnabled = webSocketEnabled
+    this.rpcBalanceAssetNames = rpcBalanceAssetNames
   }
 
   setServer(config = {}) {
@@ -215,7 +216,7 @@ export class EthereumMonitor extends BaseMonitor {
     const asset = this.asset
     const newAccountState = Object.create(null)
     const server = this.server
-    if (isRpcBalanceAsset(asset)) {
+    if (this.rpcBalanceAssetNames.includes(asset.name)) {
       const result = await server.getBalanceProxied(ourWalletAddress)
       const balance = fromHexToString(result)
       newAccountState.balance = asset.currency.baseUnit(balance)
@@ -223,7 +224,7 @@ export class EthereumMonitor extends BaseMonitor {
 
     const tokenBalancePairs = await Promise.all(
       tokens
-        .filter((token) => isRpcBalanceAsset(token) && token.contract.address)
+        .filter((token) => this.rpcBalanceAssetNames.includes(token.name) && token.contract.address)
         .map(async (token) => {
           const { confirmed } = await server.balanceOf(ourWalletAddress, token.contract.address)
           const value = token.currency.baseUnit(confirmed[token.contract.address] || 0)

package/src/tx-log/monitor-utils/get-fee-amount.js

@@ -7,5 +7,8 @@ export default function getFeeAmount(asset, serverTx) {
   // genesis, coinbase, uncles
   if (!gasPrice) return asset.currency.ZERO
 
-  return asset.currency.baseUnit(gasUsed || gasLimit).mul(gasPrice)
+  return asset.currency
+    .baseUnit(gasUsed || gasLimit)
+    .mul(gasPrice)
+    .add(asset.currency.baseUnit(serverTx.extraData?.l1Fee || 0))
 }

package/src/tx-send/index.js

@@ -1,2 +1 @@
 export { default as txSendFactory } from './tx-send.js'
-export { default as getFeeInfo } from './get-fee-info.js'

package/src/tx-send/nonce-utils.js

@@ -5,7 +5,7 @@ export const resolveNonce = async ({
   forceFromNode,
   fromAddress,
   providedNonce,
-  txLog,
+  txLog = [],
   triedNonce,
   tag = 'latest', // use 'pending' for unconfirmed txs
   useAbsoluteNonce,