@exodus/ethereum-api 8.17.0 → 8.18.0

package/CHANGELOG.md

@@ -3,6 +3,15 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.18.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.17.0...@exodus/ethereum-api@8.18.0) (2024-09-06)
+
+
+### Features
+
+* evm staking api factory ([#2473](https://github.com/ExodusMovement/assets/issues/2473)) ([3159264](https://github.com/ExodusMovement/assets/commit/315926414cfa99cb51fde2bcb44bbea478275d79))
+
+
+
 ## [8.17.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.16.0...@exodus/ethereum-api@8.17.0) (2024-08-30)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.17.0",
+  "version": "8.18.0",
   "description": "Ethereum Api",
   "type": "module",
   "main": "src/index.js",
@@ -17,7 +17,7 @@
   },
   "scripts": {
     "test": "run -T exodus-test --jest",
-    "lint": "run -T eslint .",
+    "lint": "run -T eslintc .",
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
@@ -65,5 +65,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "ea79042fc0d7ec1f4c87d3b0b511840b910ffa48"
+  "gitHead": "b03f9102b0401e40f0484c2195061a907eae9b47"
 }

package/src/staking/api/index.js

@@ -0,0 +1,34 @@
+import { pick } from '@exodus/basic-utils'
+import assert from 'minimalistic-assert'
+
+export const stakingApiFactory = ({
+  asset,
+  assetClientInterface,
+  server, // coin node server
+  stakingConfiguration,
+  stakingDependencies,
+}) => {
+  assert(asset, '"asset" is required')
+  assert(assetClientInterface, '"assetClientInterface" is required')
+  assert(server, '"server" is required')
+  assert(stakingConfiguration, '"stakingConfiguration" is required')
+  assert(stakingDependencies, '"stakingDependencies" is required')
+
+  const { contracts, minAmount } = stakingConfiguration
+  const { stakingServerFactory, stakingServiceFactory } = stakingDependencies
+
+  const stakingServer = stakingServerFactory({ asset, server, minAmount, contracts })
+
+  const stakingService = stakingServiceFactory({
+    assetClientInterface,
+    server,
+    stakingServer,
+  })
+
+  return {
+    isStaking: async ({ isDelegating }) => isDelegating,
+    isUnstaking: async ({ isUndelegateInProgress }) => isUndelegateInProgress,
+    isUnstaked: async ({ canClaimUndelegateBalance }) => canClaimUndelegateBalance,
+    ...pick(stakingService, ['approveStake', 'stake', 'unstake', 'claimUnstaked', 'claimRewards']),
+  }
+}

package/src/staking/ethereum/service.js

@@ -15,12 +15,13 @@ export function createEthereumStakingService({
 }) {
   const staking = new EthereumStaking(asset)
   const stakingProvider = stakingProviderClientFactory()
+  const minAmount = staking.minAmount
 
   function amountToCurrency({ asset, amount }) {
     return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
   }
 
-  async function delegate({ walletAccount, amount } = {}) {
+  async function delegate({ walletAccount, amount } = Object.create(null)) {
     const address = await assetClientInterface.getReceiveAddress({
       assetName: asset.name,
       walletAccount,
@@ -62,95 +63,149 @@ export function createEthereumStakingService({
     return txId
   }
 
-  async function undelegate({ walletAccount, amount } = {}) {
+  async function getUndelegatePendingData({
+    delegatorAddress,
+    resquestedAmount,
+    pendingAmount,
+    minAmount,
+  }) {
+    const leftOver = pendingAmount.sub(resquestedAmount)
+
+    if (leftOver.isPositive && leftOver.lt(minAmount)) {
+      throw new Error(`Pending balance less than min stake amount ${minAmount}`)
+    }
+
+    const inactiveAmountToUnstake = pendingAmount.lte(resquestedAmount)
+      ? pendingAmount
+      : resquestedAmount
+    const { to, data } = await staking.unstakePending({
+      address: delegatorAddress,
+      amount: inactiveAmountToUnstake,
+    })
+
+    let feeData
+    try {
+      // could revert and break the whole fee calculation
+      feeData = await estimateTxFee(delegatorAddress, to, null, data)
+    } catch {
+      console.warn('ETH unstake pending estimation reverted')
+      return Object.create(null)
+    }
+
+    return { to, txData: data, ...feeData }
+  }
+
+  async function getUndelegateData({ delegatorAddress, resquestedAmount, pendingAmount }) {
+    const canUnstake = resquestedAmount.gt(pendingAmount)
+
+    if (!canUnstake) return Object.create(null)
+
+    const activeAmountToUnstake = resquestedAmount.sub(pendingAmount)
+    const { to, data } = await staking.unstake({
+      address: delegatorAddress,
+      amount: activeAmountToUnstake,
+    })
+
+    const feeData = await estimateTxFee(delegatorAddress, to, null, data)
+
+    return { to, txData: data, ...feeData }
+  }
+
+  /**
+   * Unstaking may involve 2 txs; unstaking from pending and unstaking from validator.
+   * Fee estimation depends on the executed txs. Can be both.
+   * @returns total undelegete fee
+   */
+  async function estimateUndelegate({ walletAccount, amount: resquestedAmount }) {
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+    const pendingAmount = await staking.pendingBalanceOf(delegatorAddress)
+
+    const { fee: undelegatePendingFee = asset.currency.ZERO } = await getUndelegatePendingData({
+      delegatorAddress,
+      resquestedAmount,
+      pendingAmount,
+      minAmount,
+    })
+    const { fee: undelegateFee = asset.currency.ZERO } = await getUndelegateData({
+      delegatorAddress,
+      resquestedAmount,
+      pendingAmount,
+      minAmount,
+    })
+
+    return undelegatePendingFee.add(undelegateFee)
+  }
+
+  async function undelegate({ walletAccount, amount } = Object.create(null)) {
     /*
     unstakePending balance (not yet in validator) + unstake balance (in validator)
     1. give priority to unstakePending (based on the amount)
     2. unstake amount in validator.
     */
-    amount = amountToCurrency({ asset, amount })
+    const resquestedAmount = amountToCurrency({ asset, amount })
 
     const address = await assetClientInterface.getReceiveAddress({
       assetName: asset.name,
       walletAccount,
     })
     const delegatorAddress = address.toLowerCase()
-
     const pendingAmount = await staking.pendingBalanceOf(delegatorAddress)
 
     console.log(
-      `delegator address ${delegatorAddress} unstaking ${amount.toDefaultString({
+      `delegator address ${delegatorAddress} unstaking ${resquestedAmount.toDefaultString({
         unit: true,
       })} - pending amount: ${pendingAmount.toDefaultString({ unit: true })}`
     )
 
     let txId
-    if (!pendingAmount.isZero) {
-      const inactiveAmountToUnstake = pendingAmount.lte(amount) ? pendingAmount : amount
-      const leftOver = pendingAmount.sub(amount)
-      if (leftOver.gt(asset.currency.ZERO)) {
-        const minStake = staking.minAmount
-        if (leftOver.lt(minStake)) {
-          throw new Error(`Pending balance less than min stake amount ${minStake}`)
-        }
-      }
-
-      const { to, data } = await staking.unstakePending({
-        address: delegatorAddress,
-        amount: inactiveAmountToUnstake,
+    if (pendingAmount.isPositive) {
+      const undelegatePendingData = await getUndelegatePendingData({
+        delegatorAddress,
+        resquestedAmount,
+        pendingAmount,
+        minAmount,
       })
 
-      const { gasPrice, gasLimit, fee } = await estimateTxFee(
-        delegatorAddress.toLowerCase(),
-        to,
-        null,
-        data
-      )
       txId = await prepareAndSendTx({
         asset,
         walletAccount,
-        to,
-        txData: data,
-        gasPrice,
-        gasLimit,
-        fee,
+        ...undelegatePendingData,
       })
     }
 
-    // need also to unstake
-    if (amount.gt(pendingAmount)) {
-      const activeAmountToUnstake = amount.sub(pendingAmount)
-      const { to, data } = await staking.unstake({
-        address: delegatorAddress,
-        amount: activeAmountToUnstake,
-      })
+    // may need also to unstake
+    const undelegateData = await getUndelegateData({
+      delegatorAddress,
+      resquestedAmount,
+      pendingAmount,
+    })
 
-      const { gasPrice, gasLimit, fee } = await estimateTxFee(delegatorAddress, to, null, data)
-      txId = await prepareAndSendTx({
-        asset,
-        walletAccount,
-        to,
-        txData: data,
-        gasPrice,
-        gasLimit,
-        fee,
-      })
-    }
+    if (!undelegateData) return txId
 
-    // Goerli is not supported
+    txId = await prepareAndSendTx({
+      asset,
+      walletAccount,
+      ...undelegateData,
+    })
+
+    // Testnet assets do not support delegations tracking
     if (asset.name === 'ethereum')
       await stakingProvider.notifyUnstaking({
         txId,
         asset: asset.name,
         delegator: delegatorAddress,
-        amount: amount.toBaseString(),
+        amount: resquestedAmount.toBaseString(),
       })
 
     return txId
   }
 
-  async function claimUndelegatedBalance({ walletAccount } = {}) {
-    // withdraw withdrawable balance (of a previous unstake)
+  async function claimUndelegatedBalance({ walletAccount } = Object.create(null)) {
+    // claim withdrawable balance (of a previous unstake)
     const address = await assetClientInterface.getReceiveAddress({
       assetName: asset.name,
       walletAccount,
@@ -173,11 +228,17 @@ export function createEthereumStakingService({
         fee,
       })
     }
-
-    return null // -> no withdrawable balance
   }
 
   async function estimateDelegateOperation({ walletAccount, operation, args }) {
+    const requestedAmount = args.amount
+      ? amountToCurrency({ asset, amount: args.amount })
+      : asset.currency.ZERO
+
+    if (operation === 'undelegate') {
+      return estimateUndelegate({ walletAccount, amount: requestedAmount })
+    }
+
     const address = await assetClientInterface.getReceiveAddress({
       assetName: asset.name,
       walletAccount,
@@ -189,30 +250,18 @@ export function createEthereumStakingService({
       undelegate: 'unstake',
       claimUndelegatedBalance: 'claimWithdrawRequest',
     }
+
     const delegateOperation = staking[NAMING_MAP[operation]].bind(staking)
 
     if (!delegateOperation) {
-      return
+      throw new Error('Invalid staking operation')
     }
 
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
-    if (args.amount) args.amount = amountToCurrency({ asset, amount: args.amount })
+    const { amount, data } = await delegateOperation({ ...args, amount: requestedAmount })
+    const toAddress =
+      operation === 'claimUndelegatedBalance' ? staking.accountingAddress : staking.poolAddress
 
-    let amount, data, fee
-    try {
-      ;({ amount, data } = await delegateOperation(args))
-      const address =
-        operation === 'claimUndelegatedBalance' ? staking.accountingAddress : staking.poolAddress
-      ;({ fee } = await estimateTxFee(delegatorAddress, address, amount, data))
-    } catch (e) {
-      // If the operation is to unstake and failed retry with unstakePending
-      if (operation === 'undelegate') {
-        ;({ amount, data } = await staking.unstakePending(args))
-        ;({ fee } = await estimateTxFee(delegatorAddress, staking.poolAddress, amount, data))
-      } else {
-        throw e
-      }
-    }
+    const { fee } = await estimateTxFee(delegatorAddress, toAddress, amount, data)
 
     return fee
   }
@@ -247,16 +296,11 @@ export function createEthereumStakingService({
     return staking.minAmount
   }
 
-  async function prepareAndSendTx({
-    asset,
-    walletAccount,
-    to,
-    amount,
-    txData: txInput,
-    gasPrice,
-    gasLimit,
-    fee,
-  } = {}) {
+  async function prepareAndSendTx(
+    { asset, walletAccount, to, amount, txData: txInput, gasPrice, gasLimit, fee } = Object.create(
+      null
+    )
+  ) {
     const sendTxArgs = {
       asset,
       walletAccount,