@exodus/ethereum-api 6.3.7 → 6.3.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "6.3.7",
+  "version": "6.3.9",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "files": [
@@ -16,9 +16,9 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.7.1",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^3.3.26",
+    "@exodus/ethereum-lib": "^3.3.28",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
-    "@exodus/fetch": "^1.3.0-beta.3",
+    "@exodus/fetch": "^1.3.0-beta.4",
     "@exodus/simple-retry": "^0.0.6",
     "@exodus/solidity-contract": "^1.1.3",
     "bn.js": "^5.2.1",
@@ -34,5 +34,5 @@
   "devDependencies": {
     "@exodus/models": "^8.10.4"
   },
-  "gitHead": "23add284852287667fdf24d1c891915f4caa58bc"
+  "gitHead": "c5e6d4fb8566d79ecb82f249381e198a8d8bfb96"
 }

package/src/etherscan/request.js

@@ -1,6 +1,6 @@
 import ms from 'ms'
 import makeConcurrent from 'make-concurrent'
-import { fetchival } from '@exodus/fetch'
+import fetchival from '@exodus/fetch/experimental/fetchival'
 
 const ETHERSCAN_API_URL = 'https://api.etherscan.io/api'
 const DEFAULT_ETHERSCAN_API_KEY = 'XM3VGRSNW1TMSIR14I9MVFP15X74GNHTRI'
@@ -13,8 +13,12 @@ export function setEtherscanApiKey(apiKey) {
 
 export default makeConcurrent(
   async function(isValidResponseCheck, module, action, params = {}) {
-    const queryParams = { ...params, module, action, apiKey: etherscanApiKey }
-    const data = await fetchival(ETHERSCAN_API_URL, { timeout: ms('15s') }).get(queryParams)
+    const data = await fetchival(new URL(ETHERSCAN_API_URL), { timeout: ms('15s') }).get({
+      ...params,
+      module,
+      action,
+      apiKey: etherscanApiKey,
+    })
     if (!isValidResponseCheck(data)) throw new Error(`Invalid response: ${JSON.stringify(data)}`)
     return data.result
   },

package/src/exodus-eth-server/api.js

@@ -23,7 +23,10 @@ export function create(defaultURL, ensAssetName) {
 
   async function request(module, params = {}, { version = 'v1', method = 'get' } = {}) {
     try {
-      return await fetchival(baseUrl(version), { timeout: ms('15s') })(module)[method](params)
+      return await fetchival(baseUrl(version), { timeout: ms('15s') })(module).method(
+        method,
+        params
+      )
     } catch (err) {
       let nerr = err
       if (err.response && err.response.status === 500) {

package/src/staking/ethereum-staking-utils.js

@@ -0,0 +1,25 @@
+import { EthereumStaking } from './ethereum-staking'
+
+// stake(uint256 source)
+const DELEGATE = '0x3a29dbae'
+// unstakePending(uint256 amount)
+const UNSTAKE_PENDING = '0xed0723d4'
+
+// unstake(uint256 amount)
+const UNSTAKE = '0x2e17de78'
+
+const STAKING_MANAGER_CONTRACT = EthereumStaking.addresses.ethereum.EVERSTAKE_ADDRESS_CONTRACT_POOL
+
+export const isEthereumTx = ({ coinName }) => coinName === 'ethereum'
+export const isEthereumDelegate = (tx) =>
+  isEthereumTx(tx) && tx.to === STAKING_MANAGER_CONTRACT && tx.data?.methodId === DELEGATE
+export const isEthereumUndelegate = (tx) =>
+  isEthereumTx(tx) &&
+  tx.from[0] === STAKING_MANAGER_CONTRACT &&
+  tx.data &&
+  tx.data.methodId === UNSTAKE
+export const isEthereumClaimUndelegate = (tx) =>
+  isEthereumTx(tx) &&
+  tx.from[0] === STAKING_MANAGER_CONTRACT &&
+  tx.data &&
+  tx.data.methodId === UNSTAKE_PENDING

package/src/staking/ethereum-staking.js

@@ -0,0 +1,192 @@
+import { createContract } from '@exodus/ethereum-lib'
+import { getServerByName } from '../exodus-eth-server'
+import { retry } from '@exodus/simple-retry'
+import { bufferToHex } from '@exodus/ethereumjs-util'
+
+const MIN_AMOUNT = '0.1'
+const RETRY_DELAYS = ['10s']
+
+export class EthereumStaking {
+  static addresses = {
+    ethereum: {
+      EVERSTAKE_ADDRESS_CONTRACT_ACCOUNTING: '...', // TODO
+      EVERSTAKE_ADDRESS_CONTRACT_POOL: '...', // TODO
+    },
+    ethereumgoerli: {
+      EVERSTAKE_ADDRESS_CONTRACT_ACCOUNTING: '0x6e95818C2Dde3d87406F5C5d0A759d9372053a94',
+      EVERSTAKE_ADDRESS_CONTRACT_POOL: '0x1F28aD3B3e26192a09c1248D4092c692c32f8Ec0',
+    },
+  }
+
+  constructor(
+    asset, // ethereum or ethereumgoerli for testnet
+    minAmount = MIN_AMOUNT
+  ) {
+    this.asset = asset
+    const accountingAddress =
+      EthereumStaking.addresses[asset.name].EVERSTAKE_ADDRESS_CONTRACT_ACCOUNTING
+    const poolAddress = EthereumStaking.addresses[asset.name].EVERSTAKE_ADDRESS_CONTRACT_POOL
+
+    this.contractAccounting = createContract(accountingAddress, 'ethStakingAccounting')
+    this.contractPool = createContract(poolAddress, 'ethStakingPool')
+    this.accountingAddress = accountingAddress
+    this.poolAddress = poolAddress
+    this.minAmount = asset.currency.defaultUnit(minAmount)
+  }
+
+  buildTxData = (contract, method, ...args) => {
+    const txData = contract[method].build(...args)
+    return txData
+  }
+
+  callReadFunctionContract = (contract, method, ...args) => {
+    const callData = this.buildTxData(contract, method, ...args)
+    const data = {
+      data: bufferToHex(callData),
+      to: contract.address,
+      tag: 'latest',
+    }
+
+    const eth = getServerByName(this.asset.name)
+    return retry(eth.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
+  }
+
+  // === ACCOUNTING ===
+
+  /** Return total deposited and activated pool balance */
+  async poolsBalance() {
+    const totalPoolBalance = await this.callReadFunctionContract(this.contractAccounting, 'balance')
+    return this.asset.currency.baseUnit(totalPoolBalance)
+  }
+
+  /** Return pool pending balance. Always < 32 ETH */
+  async poolPendingBalance() {
+    const pendingBalance = await this.callReadFunctionContract(
+      this.contractAccounting,
+      'pendingBalance'
+    )
+    return this.asset.currency.baseUnit(pendingBalance)
+  }
+
+  /** Return user pending balance (waiting to be added from the Pool contract to the ETH2 validator) */
+  async pendingBalanceOf(address) {
+    let pendingBalance = await this.callReadFunctionContract(
+      this.contractAccounting,
+      'pendingBalanceOf',
+      address
+    )
+    pendingBalance = this.contractAccounting.pendingBalanceOf.parse(pendingBalance)
+    return this.asset.currency.baseUnit(pendingBalance[0])
+  }
+
+  /** Return total user autocompound balance. Part of this balance could be in pending state after rewards autocompound */
+  async autocompoundBalanceOf(address) {
+    const userBalance = await this.callReadFunctionContract(
+      this.contractAccounting,
+      'autocompoundBalanceOf',
+      address
+    )
+    return this.asset.currency.baseUnit(userBalance)
+  }
+
+  /** Return user active origin deposited balance */
+  async depositedBalanceOf(address) {
+    const depositedBalance = await this.callReadFunctionContract(
+      this.contractAccounting,
+      'depositedBalanceOf',
+      address
+    )
+    return this.asset.currency.baseUnit(depositedBalance)
+  }
+
+  /* Get earned Rewards */
+  async getLiquidRewards(address) {
+    const [compoundBalance, depositedBalance] = await Promise.all([
+      this.autocompoundBalanceOf(address),
+      this.depositedBalanceOf(address),
+    ])
+    return compoundBalance.sub(depositedBalance)
+  }
+
+  /** Return withdrawable unstaked amount  */
+  async withdrawRequest(address) {
+    let amounts = await this.callReadFunctionContract(
+      this.contractAccounting,
+      'withdrawRequest',
+      address
+    )
+    amounts = this.contractAccounting.withdrawRequest.parse(amounts)
+    return {
+      requested: this.asset.currency.baseUnit(amounts[0]),
+      readyForClaim: this.asset.currency.baseUnit(amounts[1]),
+      canSendClaimRequest: amounts[0] !== '0' && amounts[0] === amounts[1],
+    }
+  }
+
+  // === POOL ===
+
+  async stake({ amount }) {
+    if (amount.gte(this.minAmount)) {
+      return {
+        to: this.poolAddress,
+        amount,
+        data: bufferToHex(this.buildTxData(this.contractPool, 'stake', '0')), // tx data field
+      }
+    } else {
+      throw new Error(`Min Amount ${this.minAmount}`)
+    }
+  }
+
+  async unstake({ address, amount }) {
+    const amountWei = amount.toBaseString()
+    const balance = await this.autocompoundBalanceOf(address)
+
+    if (balance.gte(amount)) {
+      return {
+        to: this.poolAddress,
+        amount: this.asset.currency.ZERO,
+        data: bufferToHex(this.buildTxData(this.contractPool, 'unstake', amountWei)),
+      }
+    } else {
+      throw new Error(`Max Amount for unstake ${balance}`)
+    }
+  }
+
+  /** Claim funds requested by unstake (in withdraw state) */
+  async claimWithdrawRequest({ address }) {
+    try {
+      const rewards = await this.withdrawRequest(address)
+      if (rewards.canSendClaimRequest) {
+        return {
+          to: this.accountingAddress,
+          amount: this.asset.currency.ZERO,
+          data: bufferToHex(this.buildTxData(this.contractAccounting, 'claimWithdrawRequest')),
+        }
+      } else {
+        return null // no amount to withdraw
+      }
+    } catch (error) {
+      throw new Error(error)
+    }
+  }
+
+  /** Unstake pending funds, that are still not staked into a Validator */
+  async unstakePending({ address, amount }) {
+    const pendingBalance = await this.pendingBalanceOf(address)
+
+    if (amount.lte(pendingBalance)) {
+      try {
+        const amountWei = amount.toBaseString()
+        return {
+          to: this.poolAddress,
+          amount: this.asset.currency.ZERO,
+          data: bufferToHex(this.buildTxData(this.contractPool, 'unstakePending', amountWei)),
+        }
+      } catch (err) {
+        throw new Error(err)
+      }
+    } else {
+      throw new Error(`Min Amount ${this.minAmount}`)
+    }
+  }
+}

package/src/staking/ethereum-staking.md

@@ -0,0 +1,51 @@
+## Staking in Ethereum (ETH)
+
+## How it works?
+
+Ethereum Staking happens in the **Ethereum mainnet** network, using **Everstake** contracts.
+
+The staking contracts are deployed also to the **Goerli** testnet.
+
+## Contracts
+
+ETH Staking is handled by 2 main contracts. The Accounting Contract and the Pool Contract.
+
+#### Staking
+
+To stake we call the `stake` method with the `isAutocompound` flag set to `true`. By default Exodus users will stake with autocompound enabled.
+
+Ethereum Entry Queue is the numer of validators waiting to be operative. We can see the number of validators Entering/Exiting the chain using dashboard like https://www.validatorqueue.com/ (Currently ~43 days to get operative).
+
+#### Unstaking
+
+Unstake value from common or autocompound balance. Unstaked immediately if _value_ <= _pool pending balance_, or partially (with funds available in the pool), otherwise a withdraw request is needed (meaning the funds are staked in the Validator and will need some time to move back and be available for withdraw. Ethereum caps the number of validator withdrawals per day at 1,800, so based on the exit queue the time can vary, check the dashboard above to see how crowded is the queue and the estimated time to exit).
+
+When funds are withdrawable (`withdrawRequest(...).readyForClaim`) a `claimWithdrawRequest` tx can be broadcasted.
+
+#### Withdrawing
+
+If you stake 0.1 ETH and these funds are still pending (not in a validator but in the pool).
+You won't be able to just `unstake`. That operation is required when funds are staked already.
+
+You'll have to broadcast an `unstakePending` tx.
+
+#### Rewards
+
+Rewards are autocompounded by default.
+
+Staked balanced can be queried using `autocompoundBalanceOf`, part of this balance could be in pending state if there's not enough ETH (32 ETH) to start a new Validator.
+
+To check pending balance we can use `pendingBalanceOf`.
+
+### Staking Bussines Rules
+
+All of these rules can be queried from the smart contracts, except `minimum amount to stake`, this is defined by Everstake/Exodus.
+
+- **Minimum rewards to withdraw**: Cannot claim rewards, by default they are autocompounded
+- **Minimum amount to stake**: 0.1 ETH (contract rule)
+- **Withdrawal delay**: Cannot be predicted precisely. It depends when funds move from the Validator to the Pool (or new users funds enter the pool)
+- **Unstaking period**: immediately, but staked ETH are not available to be withdrawn before withdrawal delay.
+
+Useful resources:
+
+[Everstake wallet SDK](https://github.com/everstake/wallet-sdk/blob/main/ethereum.js)

package/src/staking/index.js

@@ -1,4 +1,6 @@
+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'

package/src/staking/matic-staking-utils.js

@@ -13,7 +13,7 @@ const STAKING_MANAGER_CONTRACT = new MaticStaking().stakingManagerContract.addre
 
 export const isPolygonTx = ({ coinName }) => coinName === 'polygon'
 export const isPolygonDelegate = (tx) =>
-  isPolygonTx(tx) && tx.to === STAKING_MANAGER_CONTRACT && tx.data && tx.data.methodId === DELEGATE
+  isPolygonTx(tx) && tx.to === STAKING_MANAGER_CONTRACT && tx.data?.methodId === DELEGATE
 export const isPolygonUndelegate = (tx) =>
   isPolygonTx(tx) &&
   tx.from[0] === STAKING_MANAGER_CONTRACT &&

package/src/staking/staking-provider-client.js

@@ -1,5 +1,5 @@
 import assert from 'minimalistic-assert'
-import { fetchival } from '@exodus/fetch'
+import fetchival from '@exodus/fetch/experimental/fetchival'
 import ms from 'ms'
 
 const DEFAULT_STAKING_URL = 'https://staking.a.exodus.io'
@@ -8,20 +8,20 @@ const HTTP_POST_TIMEOUT = ms('30s')
 export const stakingProviderClientFactory = (defaultStakingUrl = DEFAULT_STAKING_URL) => {
   assert(defaultStakingUrl, '"defaultStakingUrl" must be provided')
 
-  let stakingUrl = defaultStakingUrl
+  let stakingUrl = new URL(defaultStakingUrl) // always should be an URL instance
 
   const assetValidators = {
     polygon: '0x3f4ce357b9d61d3b904492b8b5abc69c6c693720',
   }
 
   const setStakingUrl = (newStakingUrl) => {
-    stakingUrl = newStakingUrl || defaultStakingUrl
+    stakingUrl = new URL(newStakingUrl || defaultStakingUrl)
   }
 
   const stakingRequest = ({ asset, data }) => {
-    return fetchival(`${stakingUrl}/${asset}/stake`, {
+    return fetchival(stakingUrl, {
       timeout: HTTP_POST_TIMEOUT,
-    }).post(data)
+    })(asset)('stake').post(data)
   }
 
   const notifyActionFactory = ({ type }) => {