@exodus/ethereum-api 6.3.35 → 7.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "6.3.35",
+  "version": "7.0.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -16,6 +16,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/crypto": "^1.0.0-rc.0",
+    "@exodus/currency": "^2.1.3",
     "@exodus/ethereum-lib": "^4.0.3",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/fetch": "^1.3.0-beta.4",
@@ -32,7 +33,10 @@
     "ws": "^6.1.0"
   },
   "devDependencies": {
-    "@exodus/models": "^8.10.4"
+    "@exodus/assets": "9.1.0",
+    "@exodus/assets-base": "^8.1.14",
+    "@exodus/assets-testing": "file:../../../__testing__",
+    "@exodus/models": "^11.0.0"
   },
-  "gitHead": "66d65ee9561df9952741317a358659a600dabe19"
+  "gitHead": "1ebfe4c6b2ba3cc49564290a498571e5f3921a5d"
 }

package/src/staking/index.js

@@ -1,5 +1,4 @@
-export { MaticStaking } from './matic-staking'
 export { FantomStaking } from './fantom-staking'
 export { stakingProviderClientFactory } from './staking-provider-client'
-export * from './matic-staking-utils'
 export * from './ethereum'
+export * from './matic'

package/src/staking/{matic-staking.js → matic/api.js}

@@ -1,21 +1,20 @@
 import BN from 'bn.js'
 import { createContract } from '@exodus/ethereum-lib'
 import ethAssets from '@exodus/ethereum-meta'
-import { getServerByName } from '../exodus-eth-server'
+import { getServerByName } from '../../exodus-eth-server'
 import { retry } from '@exodus/simple-retry'
 import { bufferToHex } from '@exodus/ethereumjs-util'
 
-const EVERSTAKE_VALIDATOR_CONTRACT_ADDR = '0xf30cf4ed712d3734161fdaab5b1dbb49fd2d0e5c'
-const STAKING_MANAGER_ADDR = '0x5e3ef299fddf15eaa0432e6e66473ace8c13d908'
-
 const polygonEthToken = ethAssets.find(({ name: tokenName }) => tokenName === 'polygon')
 
 const RETRY_DELAYS = ['10s']
+export class MaticStakingApi {
+  static EVERSTAKE_VALIDATOR_CONTRACT_ADDR = '0xf30cf4ed712d3734161fdaab5b1dbb49fd2d0e5c'
+  static STAKING_MANAGER_ADDR = '0x5e3ef299fddf15eaa0432e6e66473ace8c13d908'
 
-export class MaticStaking {
   constructor(
-    validatorId = EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
-    stakeManagerAddr = STAKING_MANAGER_ADDR
+    validatorId = MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+    stakeManagerAddr = MaticStakingApi.STAKING_MANAGER_ADDR
   ) {
     // harcoded exchange rate from the validtor share contract
     // in order to calculate claim unstake amount off-chain

package/src/staking/matic/index.js

@@ -0,0 +1,9 @@
+export { MaticStakingApi } from './api'
+export { createPolygonStakingService, getPolygonStakingInfo } from './service'
+export {
+  isPolygonTx,
+  isPolygonDelegate,
+  isPolygonUndelegate,
+  isPolygonReward,
+  isPolygonClaimUndelegate,
+} from './matic-staking-utils'

package/src/staking/{matic-staking-utils.js → matic/matic-staking-utils.js}

@@ -1,4 +1,4 @@
-import { MaticStaking } from './matic-staking'
+import { MaticStakingApi } from './api'
 
 // function selector for buyVoucher(uint256 _amount, uint256 _minSharesToMint)
 const DELEGATE = '0x6ab15071'
@@ -9,23 +9,16 @@ const CLAIM_REWARD = '0xc7b8981c'
 // function selector for unstakeClaimTokens_new(uint256 unbondNonce)
 const CLAIM_UNDELEGATE_BALANCE = '0xe97fddc2'
 
-const STAKING_MANAGER_CONTRACT = new MaticStaking().stakingManagerContract.address
+const STAKING_MANAGER_CONTRACT = MaticStakingApi.STAKING_MANAGER_ADDR
 
 export const isPolygonTx = ({ coinName }) => coinName === 'polygon'
 export const isPolygonDelegate = (tx) =>
   isPolygonTx(tx) && tx.to === STAKING_MANAGER_CONTRACT && tx.data?.methodId === DELEGATE
 export const isPolygonUndelegate = (tx) =>
-  isPolygonTx(tx) &&
-  tx.from[0] === STAKING_MANAGER_CONTRACT &&
-  tx.data &&
-  tx.data.methodId === UNDELEGATE
+  isPolygonTx(tx) && tx.from[0] === STAKING_MANAGER_CONTRACT && tx.data?.methodId === UNDELEGATE
 export const isPolygonReward = (tx) =>
-  isPolygonTx(tx) &&
-  tx.from[0] === STAKING_MANAGER_CONTRACT &&
-  tx.data &&
-  tx.data.methodId === CLAIM_REWARD
+  isPolygonTx(tx) && tx.from[0] === STAKING_MANAGER_CONTRACT && tx.data?.methodId === CLAIM_REWARD
 export const isPolygonClaimUndelegate = (tx) =>
   isPolygonTx(tx) &&
   tx.from[0] === STAKING_MANAGER_CONTRACT &&
-  tx.data &&
-  tx.data.methodId === CLAIM_UNDELEGATE_BALANCE
+  tx.data?.methodId === CLAIM_UNDELEGATE_BALANCE

package/src/staking/matic/service.js

@@ -0,0 +1,442 @@
+import BN from 'bn.js'
+import { getServer } from '../../exodus-eth-server'
+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 }) {
+  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 delegatorAddress = (
+      await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      })
+    ).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 delegatorAddress = (
+      await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      })
+    ).toLowerCase()
+
+    const { asset } = await getStakeAssets()
+    amount = amountToCurrency({ asset, amount })
+
+    const txUndelegateData = await stakingApi.undelegate({ amount })
+    let { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress.toLowerCase(),
+      stakingApi.validatorShareContract.address,
+      txUndelegateData
+    )
+    const txId = await prepareAndSendTx({
+      walletAccount,
+      to: stakingApi.validatorShareContract.address,
+      txData: txUndelegateData,
+      gasPrice,
+      gasLimit,
+      fee,
+    })
+
+    return txId
+  }
+
+  async function claimRewards({ walletAccount } = {}) {
+    const delegatorAddress = (
+      await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      })
+    ).toLowerCase()
+
+    const txWithdrawRewardsData = await stakingApi.withdrawRewards()
+    let { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress,
+      stakingApi.validatorShareContract.address,
+      txWithdrawRewardsData
+    )
+    const txId = await prepareAndSendTx({
+      walletAccount,
+      to: stakingApi.validatorShareContract.address,
+      txData: txWithdrawRewardsData,
+      gasPrice,
+      gasLimit,
+      fee,
+    })
+
+    return txId
+  }
+
+  async function claimUndelegatedBalance({ walletAccount, unbondNonce } = {}) {
+    const delegatorAddress = (
+      await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      })
+    ).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 })
+    let { 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 delegatorAddress = (
+      await assetClientInterface.getReceiveAddress({
+        assetName,
+        walletAccount,
+      })
+    ).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 = 240000
+    const gasPrice = parseInt(await getServer(ethereum).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 getServer(ethereum).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 }) {
+  const { currency } = asset
+  const stakingApi = new MaticStakingApi()
+  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/tx-log/clarity-utils/get-log-items-from-server-tx.js

@@ -76,6 +76,10 @@ export default function getLogItemsFromServerTx({
             internalTransfers,
             erc20Transfers,
           }),
+          currencies: {
+            [asset.name]: asset.currency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
         },
       ])
     }
@@ -118,6 +122,10 @@ export default function getLogItemsFromServerTx({
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: token.feeAsset.name }
           : { from: tokenFromAddresses }),
         selfSend,
+        currencies: {
+          [token.name]: token.currency,
+          [token.feeAsset.name]: token.feeAsset.currency,
+        },
       },
     ])
   })

package/src/tx-log/monitor-utils/get-log-items-from-server-tx.js

@@ -75,6 +75,10 @@ export default function getLogItemsFromServerTx({
             serverTx,
             ourWalletAddress,
           }),
+          currencies: {
+            [asset.name]: asset.currency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
         },
       ])
     }
@@ -120,6 +124,10 @@ export default function getLogItemsFromServerTx({
           ? { from: [], to: tokenTransferToAddress, feeAmount, feeCoinName: asset.feeAsset.name }
           : { from: tokenFromAddresses }),
         selfSend,
+        currencies: {
+          [token.name]: token.currency,
+          [token.feeAsset.name]: token.feeAsset.currency,
+        },
       },
     ])
   })