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

package/src/tx-create.js

@@ -1,352 +0,0 @@
-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,
-    })
-  }
-}