@exodus/ethereum-api 6.3.15 → 6.3.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "6.3.15",
+  "version": "6.3.16",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@exodus/models": "^8.10.4"
   },
-  "gitHead": "f3e3f031b8de37e0540523227469c0991d90c8b3"
+  "gitHead": "4a98199d02033b9d822b2065f3725a3bd4a1b83d"
 }

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

@@ -1,5 +1,5 @@
 import { createContract } from '@exodus/ethereum-lib'
-import { getServerByName } from '../exodus-eth-server'
+import { getServerByName } from '../../exodus-eth-server'
 import { retry } from '@exodus/simple-retry'
 import { bufferToHex } from '@exodus/ethereumjs-util'
 

package/src/staking/ethereum/index.js

@@ -0,0 +1,3 @@
+export * from './staking-utils'
+export * from './api'
+export * from './service'

package/src/staking/ethereum/service.js

@@ -0,0 +1,267 @@
+import { estimateGasLimit, EthereumStaking, getServer } from '@exodus/ethereum-api'
+import BN from 'bn.js'
+
+const delegateGas = 500000 // approx gas limits
+
+export function createEthereumStakingService({
+  asset,
+  assetClientInterface,
+  createAndBroadcastTX,
+}) {
+  const staking = new EthereumStaking(asset)
+
+  async function delegate({ walletAccount, delegatorAddress, amount } = {}) {
+    const _delegatorAddress = delegatorAddress.toLowerCase()
+
+    const { to, data } = await staking.stake({
+      amount,
+    })
+
+    const { gasPrice, gasLimit, fee } = await estimateTxFee(_delegatorAddress, to, amount, data)
+
+    console.log(
+      `delegator address ${delegatorAddress} staking ${amount.toDefaultString({
+        unit: true,
+      })}`
+    )
+    const txId = await prepareAndSendTx({
+      asset,
+      walletAccount,
+      to,
+      amount,
+      txData: data,
+      gasPrice,
+      gasLimit,
+      fee,
+    })
+
+    return txId
+  }
+
+  async function undelegate({ walletAccount, delegatorAddress, amount } = {}) {
+    /*
+    unstakePending balance (not yet in validator) + unstake balance (in validator)
+    1. give priority to unstakePending (based on the amount)
+    2. unstake amount in validator.
+    */
+
+    const pendingAmount = await staking.pendingBalanceOf(delegatorAddress)
+
+    console.log(
+      `delegator address ${delegatorAddress} unstaking ${amount.toDefaultString({
+        unit: true,
+      })} - pending amount: ${pendingAmount.toDefaultString({ unit: true })}`
+    )
+
+    let txId
+    if (!pendingAmount.isZero) {
+      const { to, data } = await staking.unstakePending({
+        address: delegatorAddress,
+        amount,
+      })
+
+      let { gasPrice, gasLimit, fee } = await estimateTxFee(
+        delegatorAddress.toLowerCase(),
+        to,
+        null,
+        data
+      )
+      txId = await prepareAndSendTx({
+        asset,
+        walletAccount,
+        to: to,
+        txData: data,
+        gasPrice,
+        gasLimit,
+        fee,
+      })
+    }
+
+    // need also to unstake
+    if (amount.gt(pendingAmount)) {
+      const amountToUnstake = amount.sub(pendingAmount)
+      const { to, data } = await staking.unstake({
+        address: delegatorAddress,
+        amount: amountToUnstake,
+      })
+
+      let { gasPrice, gasLimit, fee } = await estimateTxFee(delegatorAddress, to, null, data)
+      txId = await prepareAndSendTx({
+        asset,
+        walletAccount,
+        to,
+        txData: data,
+        gasPrice,
+        gasLimit,
+        fee,
+      })
+    }
+
+    return txId
+  }
+
+  async function claimUndelegatedBalance({ walletAccount, delegatorAddress } = {}) {
+    // withdraw withdrawable balance (of a previous unstake)
+
+    const withdrawRequest = await staking.claimWithdrawRequest({
+      address: delegatorAddress,
+    })
+    if (withdrawRequest) {
+      const { to, data } = withdrawRequest
+      let { gasPrice, gasLimit, fee } = await estimateTxFee(delegatorAddress, to, null, data)
+      const txId = await prepareAndSendTx({
+        asset,
+        walletAccount,
+        to: to,
+        txData: data,
+        gasPrice,
+        gasLimit,
+        fee,
+      })
+      return txId
+    } else return null // -> no withdrawable balance
+  }
+
+  async function estimateDelegateOperation({ delegatorAddress, operation, args }) {
+    const NAMING_MAP = {
+      delegate: 'stake',
+      undelegate: 'unstake',
+      claimUndelegatedBalance: 'claimWithdrawRequest',
+    }
+    const delegateOperation = staking[NAMING_MAP[operation]].bind(staking)
+
+    if (!delegateOperation) {
+      return
+    }
+
+    const { amount, data } = await delegateOperation(args)
+    const { fee } = await estimateTxFee(delegatorAddress, staking.poolAddress, amount, data)
+
+    return fee
+  }
+
+  async function estimateUndelegateTxFee() {
+    const gasPrice = parseInt(await getServer(asset).gasPrice(), 16)
+
+    const gasLimit = delegateGas
+    const fee = new BN(gasLimit).mul(new BN(gasPrice))
+    return {
+      gasLimit,
+      gasPrice: asset.currency.baseUnit(gasPrice),
+      fee: asset.currency.baseUnit(fee.toString()),
+    }
+  }
+
+  async function estimateTxFee(from, to, amount, txInput, gasPrice = '0x0') {
+    amount = amount || asset.currency.ZERO
+    if (amount.isZero) {
+      // unstaking txs
+      return estimateUndelegateTxFee() // otherwise server estimateGasLimit will throw "execution reverted"
+    }
+
+    const gasLimit = await estimateGasLimit(
+      asset,
+      from.toLowerCase(),
+      to.toLowerCase(),
+      amount, // staking contracts does not always require ETH amount to interact with
+      txInput,
+      gasPrice
+    )
+
+    if (gasPrice === '0x0') {
+      gasPrice = await getServer(asset).gasPrice()
+    }
+
+    gasPrice = parseInt(gasPrice, 16)
+    const fee = new BN(gasPrice).mul(new BN(gasLimit))
+
+    return {
+      gasLimit,
+      gasPrice: asset.currency.baseUnit(gasPrice),
+      fee: asset.currency.baseUnit(fee.toString()),
+    }
+  }
+
+  function getMinAmount() {
+    return staking.minAmount
+  }
+
+  async function prepareAndSendTx({
+    asset,
+    walletAccount,
+    to,
+    amount,
+    txData: txInput,
+    gasPrice,
+    gasLimit,
+    fee,
+  } = {}) {
+    const sendTxArgs = {
+      asset,
+      walletAccount,
+      address: to,
+      amount: amount || asset.currency.ZERO,
+      options: {
+        shouldLog: true,
+        txInput,
+        gasPrice,
+        gasLimit,
+        feeAmount: fee,
+      },
+    }
+
+    console.log('sending staking tx:', sendTxArgs)
+
+    const { txId } = await createAndBroadcastTX(sendTxArgs)
+
+    return txId
+  }
+
+  return {
+    delegate,
+    undelegate,
+    claimUndelegatedBalance,
+    getEthereumStakingInfo,
+    estimateDelegateOperation,
+    getMinAmount,
+  }
+}
+
+export async function getEthereumStakingInfo({ address, asset }) {
+  const { currency } = asset
+  const delegator = address.toLowerCase()
+  const staking = new EthereumStaking(asset)
+
+  const [activeStakedBalance, pendingBalance, withdrawRequest, rewardsBalance] = await Promise.all([
+    staking.autocompoundBalanceOf(delegator),
+    staking.pendingBalanceOf(delegator),
+    staking.withdrawRequest(delegator),
+    staking.getLiquidRewards(delegator),
+  ])
+
+  const delegatedBalance = activeStakedBalance.add(pendingBalance)
+  const minDelegateAmount = currency.defaultUnit(0.1)
+
+  const {
+    requested,
+    canSendClaimRequest,
+    /*, readyForClaim */
+  } = withdrawRequest
+
+  const isDelegating = !delegatedBalance.isZero || !requested.isZero
+  const isUndelegateInProgress = !requested.isZero && !canSendClaimRequest
+
+  const canClaimUndelegatedBalance = canSendClaimRequest
+
+  const unclaimedUndelegatedBalance = requested
+
+  return {
+    rewardsBalance,
+    isDelegating,
+    delegatedBalance,
+    minDelegateAmount,
+    unclaimedUndelegatedBalance,
+    canClaimUndelegatedBalance,
+    isUndelegateInProgress,
+  }
+}

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

@@ -1,4 +1,4 @@
-import { EthereumStaking } from './ethereum-staking'
+import { EthereumStaking } from './api'
 
 const { DELEGATE, UNSTAKE, UNSTAKE_PENDING } = EthereumStaking.METHODS_IDS
 

package/src/staking/index.js

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