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

package/src/get-fee-async.js

@@ -1,97 +0,0 @@
-import assert from 'minimalistic-assert'
-import { fetchGasLimit } from './gas-estimation'
-import { isForwarderContractCached } from './eth-like-util'
-import { getFeeFactory } from './get-fee'
-
-const FIXED_TRANSFER_GAS_LIMIT_ASSETS = new Set([
-  'amp',
-  'tetherusd',
-  'usdcoin',
-  'snx',
-  'geminidollar',
-])
-
-async function resolveExtraPercentage({ asset, toAddress }) {
-  const isToken = asset.name !== asset.baseAsset.name
-  // calling forwarder contracts with a bumped gas limit causes 'Out Of Gas' error on chain
-  const hasForwarderContract =
-    !isToken && toAddress ? await isForwarderContractCached({ asset, address: toAddress }) : false
-
-  return asset.baseAsset.estimateL1DataFee
-    ? 100
-    : (isToken && FIXED_TRANSFER_GAS_LIMIT_ASSETS.has(asset.name)) || hasForwarderContract
-      ? 0
-      : undefined
-}
-
-const getFeeAsyncFactory = ({
-  assetClientInterface,
-  gasLimit: defaultGasLimit,
-  createUnsignedTx,
-}) => {
-  assert(assetClientInterface, 'assetClientInterface is required')
-  assert(createUnsignedTx, 'createUnsignedTx is required')
-  const getFee = getFeeFactory({ gasLimit: defaultGasLimit })
-  return async ({
-    asset,
-    fromAddress = '0xffffffffffffffffffffffffffffffffffffffff', // sending from a random address
-    toAddress = '0xffffffffffffffffffffffffffffffffffffffff', // sending to a random address,
-    amount,
-    bip70,
-    txInput,
-    isExchange,
-    customFee,
-    calculateEffectiveFee,
-    isSendAll,
-    isRbfAllowed = true, // Destkop, isRbfAllowed=true when advanced panel is on
-    throwOnError = false,
-  }) => {
-    const extraPercentage = await resolveExtraPercentage({ asset, toAddress })
-
-    const gasLimit = await fetchGasLimit({
-      asset,
-      fromAddress,
-      toAddress,
-      txInput: txInput ?? '0x', // default value is '0x'
-      amount,
-      bip70,
-      throwOnError,
-      extraPercentage,
-    })
-    const feeData = await assetClientInterface.getFeeConfig({ assetName: asset.baseAsset.name })
-
-    const optimismL1DataFee = asset.baseAsset.estimateL1DataFee
-      ? await asset.baseAsset.estimateL1DataFee({
-          unsignedTx: createUnsignedTx({
-            asset,
-            address: toAddress,
-            fromAddress,
-            amount,
-            nonce: 0,
-            txInput,
-            gasPrice: feeData.gasPrice,
-            gasLimit,
-          }),
-        })
-      : undefined
-
-    const { fee, ...rest } = getFee({
-      asset,
-      feeData,
-      gasLimit,
-      isExchange,
-      isSendAll,
-      amount,
-      isRbfAllowed,
-      calculateEffectiveFee, // BE
-      customFee, // BE
-    })
-
-    const l1DataFee = optimismL1DataFee
-      ? asset.baseAsset.currency.baseUnit(optimismL1DataFee)
-      : asset.baseAsset.currency.ZERO
-    return { fee: fee.add(l1DataFee), optimismL1DataFee, gasLimit, ...rest }
-  }
-}
-
-export default getFeeAsyncFactory

package/src/staking/matic/service.js

@@ -1,437 +0,0 @@
-import BN from 'bn.js'
-import { estimateGasLimit } from '../../gas-estimation'
-import { MaticStakingApi } from './api'
-import { stakingProviderClientFactory } from '../staking-provider-client'
-import { isNumberUnit } from '@exodus/currency'
-
-export function createPolygonStakingService({
-  assetClientInterface,
-  createAndBroadcastTX,
-  server,
-}) {
-  const stakingApi = new MaticStakingApi()
-  const assetName = 'ethereum'
-  const stakingProvider = stakingProviderClientFactory()
-
-  async function getStakeAssets() {
-    const { polygon: asset, ethereum: feeAsset } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: assetName,
-    })
-    return { asset, feeAsset }
-  }
-
-  function amountToCurrency({ asset, amount }) {
-    return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
-  }
-
-  async function delegate({ walletAccount, amount } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
-
-    const { asset } = await getStakeAssets()
-    amount = amountToCurrency({ asset, amount })
-
-    const txApproveData = await stakingApi.approveStakeManager(amount)
-    let { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.polygonContract.address,
-      txApproveData
-    )
-    await prepareAndSendTx({
-      walletAccount,
-      waitForConfirmation: true,
-      to: stakingApi.polygonContract.address,
-      txData: txApproveData,
-      gasPrice,
-      gasLimit,
-      fee,
-    })
-
-    const txDelegateData = await stakingApi.delegate({ amount })
-    ;({ gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      txDelegateData
-    ))
-
-    const txId = await prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txDelegateData,
-      gasPrice,
-      gasLimit,
-      fee,
-    })
-
-    await stakingProvider.notifyStaking({
-      txId,
-      asset: asset.name,
-      delegator: delegatorAddress,
-      amount: amount.toBaseString(),
-    })
-
-    return txId
-  }
-
-  async function undelegate({ walletAccount, amount } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
-
-    const { asset } = await getStakeAssets()
-    amount = amountToCurrency({ asset, amount })
-
-    const txUndelegateData = await stakingApi.undelegate({ amount })
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress.toLowerCase(),
-      stakingApi.validatorShareContract.address,
-      txUndelegateData
-    )
-    return prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txUndelegateData,
-      gasPrice,
-      gasLimit,
-      fee,
-    })
-  }
-
-  async function claimRewards({ walletAccount } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
-
-    const txWithdrawRewardsData = await stakingApi.withdrawRewards()
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      txWithdrawRewardsData
-    )
-    return prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txWithdrawRewardsData,
-      gasPrice,
-      gasLimit,
-      fee,
-    })
-  }
-
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce } = {}) {
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
-
-    const { asset } = await getStakeAssets()
-    const { currency } = asset
-    const unstakedClaimInfo = await fetchUnstakedClaimInfo({
-      stakingApi,
-      delegator: delegatorAddress,
-    })
-
-    const { unclaimedUndelegatedBalance } = await getUnstakedUnclaimedInfo({
-      stakingApi,
-      currency,
-      delegator: delegatorAddress,
-      ...unstakedClaimInfo,
-    })
-
-    const txClaimUndelegatedData = await stakingApi.claimUndelegatedBalance({ unbondNonce })
-    const { gasPrice, gasLimit, fee } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      txClaimUndelegatedData
-    )
-    const txId = await prepareAndSendTx({
-      walletAccount,
-      to: stakingApi.validatorShareContract.address,
-      txData: txClaimUndelegatedData,
-      gasPrice,
-      gasLimit,
-      fee,
-    })
-
-    await stakingProvider.notifyUnstaking({
-      txId,
-      asset: asset.name,
-      delegator: delegatorAddress,
-      amount: unclaimedUndelegatedBalance.toBaseString(),
-    })
-
-    return txId
-  }
-
-  async function estimateDelegateOperation({ walletAccount, operation, args }) {
-    const delegateOperation = stakingApi[operation]
-
-    if (!delegateOperation) {
-      return
-    }
-
-    const address = await assetClientInterface.getReceiveAddress({
-      assetName,
-      walletAccount,
-    })
-    const delegatorAddress = address.toLowerCase()
-
-    const { amount } = args
-    if (amount) {
-      const { asset } = await getStakeAssets()
-      args = { ...args, amount: amountToCurrency({ asset, amount }) }
-    }
-
-    const operationTxData = await delegateOperation({ ...args, walletAccount })
-    const { fee } = await estimateTxFee(
-      delegatorAddress,
-      stakingApi.validatorShareContract.address,
-      operationTxData
-    )
-
-    return fee
-  }
-
-  /**
-   * Estimating delegete tx using {estimateGasLimit} function does not work
-   * as the execution reverts (due to missing MATIC approval).
-   * Instead, a fixed gas limit is use, which is:
-   *
-   * delegateGasLimit = ERC20ApproveGas + delegateGas
-   *
-   * This is just for displaying purposes and it's just an aproximation of the delegate gas cost,
-   * NOT the real fee cost
-   */
-  async function estimateDelegateTxFee() {
-    // approx gas limits
-    const { ethereum } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum',
-    })
-    const erc20ApproveGas = 4900
-    const delegateGas = 240_000
-    const gasPrice = parseInt(await server.gasPrice(), 16)
-    const extraPercentage = 20
-
-    const gasLimit = erc20ApproveGas + delegateGas
-    const gasLimitWithBuffer = new BN(gasLimit)
-      .imuln(100 + extraPercentage)
-      .idivn(100)
-      .toString()
-
-    const fee = new BN(gasLimitWithBuffer).mul(new BN(gasPrice))
-
-    return {
-      gasLimit: gasLimitWithBuffer,
-      gasPrice,
-      fee: ethereum.currency.baseUnit(fee.toString()),
-    }
-  }
-
-  async function estimateTxFee(from, to, txInput, gasPrice = '0x0') {
-    const { ethereum } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum',
-    })
-    const amount = ethereum.currency.ZERO
-    const gasLimit = await estimateGasLimit(
-      ethereum,
-      from,
-      to,
-      amount, // staking contracts does not require ETH amount to interact with
-      txInput,
-      gasPrice
-    )
-
-    if (gasPrice === '0x0') {
-      gasPrice = await server.gasPrice()
-    }
-
-    gasPrice = parseInt(gasPrice, 16)
-    const fee = new BN(gasPrice).mul(new BN(gasLimit))
-
-    return {
-      gasLimit,
-      gasPrice: ethereum.currency.baseUnit(gasPrice),
-      fee: ethereum.currency.baseUnit(fee.toString()),
-    }
-  }
-
-  async function prepareAndSendTx({
-    walletAccount,
-    to,
-    txData: txInput,
-    gasPrice,
-    gasLimit,
-    fee,
-    waitForConfirmation = false,
-  } = {}) {
-    const { ethereum } = await assetClientInterface.getAssetsForNetwork({
-      baseAssetName: 'ethereum',
-    })
-    const sendTxArgs = {
-      asset: ethereum,
-      walletAccount,
-      address: to,
-      amount: ethereum.currency.ZERO,
-      options: {
-        shouldLog: true,
-        txInput,
-        gasPrice,
-        gasLimit,
-        feeAmount: fee,
-      },
-      waitForConfirmation,
-    }
-
-    const { txId } = await createAndBroadcastTX(sendTxArgs)
-
-    return txId
-  }
-
-  return {
-    delegate,
-    undelegate,
-    claimRewards,
-    claimUndelegatedBalance,
-    getPolygonStakingInfo,
-    estimateDelegateTxFee,
-    estimateDelegateOperation,
-  }
-}
-
-async function fetchUnstakedClaimInfo({ stakingApi, delegator }) {
-  const [unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate] = await Promise.all([
-    stakingApi.getCurrentUnbondNonce(delegator),
-    stakingApi.getWithdrawalDelay(),
-    stakingApi.getCurrentCheckpoint(),
-    stakingApi.getWithdrawExchangeRate(),
-  ])
-
-  return {
-    unbondNonce,
-    withdrawalDelay,
-    currentEpoch,
-    withdrawExchangeRate,
-  }
-}
-
-function calculateUnclaimedTokens({
-  currency,
-  exchangeRatePrecision,
-  withdrawExchangeRate,
-  shares,
-  canClaimUndelegatedBalance,
-  isUndelegateInProgress,
-}) {
-  // see contract implementation
-  // https://github.com/maticnetwork/contracts/blob/1eb6960e511a967c15d4936904570a890d134fa6/contracts/staking/validatorShare/ValidatorShare.sol#L304
-  if (canClaimUndelegatedBalance || isUndelegateInProgress) {
-    const unclaimedTokens = withdrawExchangeRate
-      .mul(shares) // shares === validator tokens
-      .div(exchangeRatePrecision)
-      .toString()
-
-    return currency.baseUnit(unclaimedTokens)
-  }
-
-  return currency.ZERO
-}
-
-function canClaimUndelegatedBalance({ shares, withdrawEpoch, isUndelegateInProgress }) {
-  const undelegateNotStarted = shares.isZero() && withdrawEpoch.isZero()
-  return !(isUndelegateInProgress || undelegateNotStarted)
-}
-
-async function getUnstakedUnclaimedInfo({
-  stakingApi,
-  currency,
-  delegator,
-  unbondNonce,
-  currentEpoch,
-  withdrawalDelay,
-  withdrawExchangeRate,
-}) {
-  const { withdrawEpoch, shares } = await stakingApi.getUnboundInfo(delegator, unbondNonce)
-  const exchangeRatePrecision = stakingApi.EXCHANGE_RATE_PRECISION
-  const isUndelegateInProgress =
-    !withdrawEpoch.isZero() && withdrawEpoch.add(withdrawalDelay).gte(currentEpoch)
-  const isUndelegatedBalanceClaimable = canClaimUndelegatedBalance({
-    shares,
-    withdrawEpoch,
-    isUndelegateInProgress,
-  })
-  const unclaimedUndelegatedBalance = calculateUnclaimedTokens({
-    currency,
-    exchangeRatePrecision,
-    withdrawExchangeRate,
-    shares,
-    canClaimUndelegatedBalance: isUndelegatedBalanceClaimable,
-    isUndelegateInProgress,
-  })
-  return {
-    isUndelegateInProgress,
-    canClaimUndelegatedBalance: isUndelegatedBalanceClaimable,
-    unclaimedUndelegatedBalance,
-  }
-}
-
-async function fetchRewardsInfo({ stakingApi, delegator, currency }) {
-  const [minRewardsToWithdraw, rewardsBalance] = await Promise.all([
-    stakingApi.getMinRewardsToWithdraw(),
-    stakingApi.getLiquidRewards(delegator),
-  ])
-  const withdrawable = rewardsBalance.sub(minRewardsToWithdraw).gte(currency.ZERO)
-    ? rewardsBalance
-    : currency.ZERO
-
-  return {
-    rewardsBalance,
-    minRewardsToWithdraw,
-    withdrawable,
-  }
-}
-
-export async function getPolygonStakingInfo({ address, asset, server }) {
-  const { currency } = asset
-  const stakingApi = new MaticStakingApi({ server })
-  const delegator = address.toLowerCase()
-  const [
-    delegatedBalance,
-    { rewardsBalance, minRewardsToWithdraw, withdrawable },
-    { unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate },
-  ] = await Promise.all([
-    stakingApi.getTotalStake(delegator),
-    fetchRewardsInfo({ stakingApi, delegator, currency }),
-    fetchUnstakedClaimInfo({ stakingApi, delegator }),
-  ])
-  const minDelegateAmount = currency.defaultUnit(1)
-  const isDelegating = !delegatedBalance.isZero
-
-  const unclaimedUndelegatedInfo = await getUnstakedUnclaimedInfo({
-    stakingApi,
-    currency,
-    delegator,
-    unbondNonce,
-    currentEpoch,
-    withdrawalDelay,
-    withdrawExchangeRate,
-  })
-
-  return {
-    rewardsBalance,
-    withdrawable,
-    unbondNonce,
-    isDelegating,
-    delegatedBalance,
-    minRewardsToWithdraw,
-    minDelegateAmount,
-    ...unclaimedUndelegatedInfo,
-  }
-}

package/src/staking-api.js

@@ -1,5 +0,0 @@
-export function createStakingApi({ network }) {
-  return {
-    isStaking: ({ accountState }) => accountState.staking[network]?.isDelegating,
-  }
-}

package/src/tx-log/clarity-utils/get-derive-data-needed-for-tick.js

@@ -1,12 +0,0 @@
-// A super-selector that returns all the current data needed for a tick of the ETH monitor.
-
-export default function getDeriveDataNeededForTick(aci) {
-  return async function ({ assetName, walletAccount }) {
-    const receiveAddress = await aci.getReceiveAddress({ assetName, walletAccount, useCache: true })
-    const currentAccountState = await aci.getAccountState({ assetName, walletAccount })
-    return {
-      ourWalletAddress: receiveAddress.toLowerCase(),
-      currentAccountState,
-    }
-  }
-}

package/src/tx-log-staking-processor/get-asset-tx-amount.js

@@ -1,26 +0,0 @@
-import { calculateTxAmountAndRewardFromStakeTx } from './utils.js'
-
-const getPolygonTxAmount = ({ currency, tx, type, server }) => {
-  if ('delegate' in type) {
-    return calculateTxAmountAndRewardFromStakeTx({ tx, currency, server })
-  }
-
-  return currency.ZERO
-}
-
-const getEthereumTxAmount = ({ currency, tx, type }) => {
-  const isStakingTx = ['delegate', 'undelegatePending', 'undelegate', 'claimUndelegate'].some(
-    (stakingType) => type[stakingType]
-  )
-  if (isStakingTx) {
-    return currency.ZERO
-  }
-
-  return tx.coinAmount
-}
-
-export const getStakeTxAmount = {
-  polygon: getPolygonTxAmount,
-  ethereum: getEthereumTxAmount,
-  ethereumholesky: getEthereumTxAmount,
-}

package/src/tx-send/get-fee-info.js

@@ -1,41 +0,0 @@
-import { fetchGasLimit } from '../gas-estimation'
-
-const getFeeInfo = async function getFeeInfo({
-  assetClientInterface,
-  asset,
-  fromAddress,
-  toAddress,
-  amount,
-  isExchange,
-  txInput,
-  feeOpts = {},
-}) {
-  const {
-    gasPrice: gasPrice_,
-    tipGasPrice: tipGasPrice_,
-    gasPriceEconomicalRate,
-  } = await assetClientInterface.getFeeData({
-    assetName: asset.name,
-  })
-
-  let { gasLimit, gasPrice = gasPrice_, tipGasPrice = tipGasPrice_ } = feeOpts
-
-  if (!gasLimit) {
-    gasLimit = await fetchGasLimit({
-      asset,
-      fromAddress,
-      toAddress,
-      amount,
-      txInput,
-      throwOnError: false,
-      isContract: feeOpts.isContract ?? undefined,
-    })
-  }
-
-  const economicalFeeMultiplier = isExchange ? 1 : gasPriceEconomicalRate || 1
-
-  const fee = gasPrice.mul(economicalFeeMultiplier).mul(gasLimit)
-  return { gasPrice, gasLimit, fee, tipGasPrice }
-}
-
-export default getFeeInfo

package/src/websocket/index.android.js

@@ -1,2 +0,0 @@
-/* global WebSocket */
-export default WebSocket

package/src/websocket/index.ios.js

@@ -1,2 +0,0 @@
-/* global WebSocket */
-export default WebSocket

package/src/websocket/index.js

@@ -1,21 +0,0 @@
-/**
- * This is a "light" version of @exodus/core resolution to select the native WebSocket on BE
- * It's a workaround until https://github.com/ExodusMovement/assets/pull/72 is merged.
- *
- * Based on https://github.com/ExodusMovement/fetch/blob/master/core.js , note that chooses native on Desktop
- */
-if (typeof process !== 'undefined' && (process.type === 'renderer' || process.type === 'worker')) {
-  // THIS IS FOR DESKTOP
-  if (process.env.EXODUS_DISABLE_WS) {
-    module.exports = globalThis.WebSocket
-  } else {
-    module.exports = require('ws')
-  }
-  // eslint-disable-next-line no-undef
-} else if (typeof WebSocket === 'undefined') {
-  // THIS IS FOR UNIT TESTING.
-  module.exports = require('ws')
-} else {
-  // THIS IS FOR BE
-  module.exports = globalThis.WebSocket
-}