@exodus/ethereum-api 2.13.1 → 2.14.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "2.13.1",
+  "version": "2.14.0",
   "description": "Ethereum Api",
   "main": "src/index.js",
   "author": "Exodus Movement, Inc.",
@@ -12,7 +12,7 @@
   "dependencies": {
     "@exodus/asset-lib": "^3.5.4",
     "@exodus/crypto": "^1.0.0-rc.0",
-    "@exodus/ethereum-lib": "^2.13.5",
+    "@exodus/ethereum-lib": "^2.14.0",
     "@exodus/ethereumjs-util": "^7.1.0-exodus.6",
     "@exodus/simple-retry": "^0.0.6",
     "fetchival": "0.3.3",
@@ -28,5 +28,5 @@
     "@exodus/assets-base": "^8.0.136",
     "@exodus/models": "^8.7.2"
   },
-  "gitHead": "7d9f726b6115d756d5fbed46664d466972c0f314"
+  "gitHead": "f898e71ce1f19bbb5cd35327f4708f55a7bcb72c"
 }

package/src/index.js

@@ -7,3 +7,4 @@ export * from './gas-estimation'
 export * from './exodus-eth-server'
 export * from './tx-log'
 export * from './get-balances'
+export * from './staking'

package/src/staking/fantom-staking.js

@@ -0,0 +1,115 @@
+import { createContract } from '@exodus/ethereum-lib'
+
+export const SFC_ADDRESS = '0xfc00face00000000000000000000000000000000'
+
+export class FantomStaking {
+  constructor() {
+    this.sfcContract = createContract(SFC_ADDRESS, 'fantomSfc')
+  }
+
+  buildTxData = (contract, method, ...args) => {
+    return contract[method].build(...args)
+  }
+
+  /**
+   * Get tx data of method to delegate (stake) amount to validator
+   */
+  delegate = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'delegate', validatorId)
+  }
+
+  /**
+   * undelegate creates a transaction preparing part of the delegations
+   * to be withdrawn.
+   *
+   * Note: The amount must be lower than the total delegation amount for that account. Also,
+   * the requestId value has to be unique and previously unused numeric identifier of the new
+   * withdrawal. The actual withdraw execution, available after a lock period, will use the same
+   * request id to process the prepared withdrawal.
+   */
+  undelegate = ({ requestId, validatorId, amount }) => {
+    this.#validateRequestId(requestId)
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'undelegate', validatorId, requestId, amount)
+  }
+
+  /**
+   * withdraw creates a transaction executing partial withdraw for the given
+   * prepared withdraw request.
+   *
+   * Note: The request id has to exist and has to be prepared for the withdraw to execute
+   * correctly.
+   */
+  withdraw = ({ requestId, validatorId }) => {
+    this.#validateRequestId(requestId)
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'withdraw', validatorId, requestId)
+  }
+
+  /**
+   * claimRewards creates a new delegator rewards claiming transaction.
+   * The call transfers all the rewards from SFC back to the stake in single transaction.
+   */
+  claimRewards = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'claimRewards', validatorId)
+  }
+
+  /**
+   * restakeRewards creates a new delegator rewards claiming transaction.
+   * The call transfers all the rewards from SFC back to the stake in single transaction.
+   */
+  restakeRewards = ({ validatorId }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'restakeRewards', validatorId)
+  }
+
+  /**
+   * lockStake creates a transaction for locking delegation.
+   */
+  lockStake = ({ validatorId, amount, durationSeconds }) => {
+    this.#validateValidatorId(validatorId)
+    this.#validateDuration(durationSeconds)
+    return this.buildTxData(this.sfcContract, 'lockStake', validatorId, durationSeconds, amount)
+  }
+
+  /**
+   * relockStake creates a transaction for re-locking delegation.
+   */
+  relockStake = ({ validatorId, amount, durationSeconds }) => {
+    this.#validateValidatorId(validatorId)
+    this.#validateDuration(durationSeconds)
+    return this.buildTxData(this.sfcContract, 'relockStake', validatorId, durationSeconds, amount)
+  }
+
+  /**
+   * unlockStake creates a transaction for unlocking delegation.
+   */
+  unlockStake = ({ validatorId, amount }) => {
+    this.#validateValidatorId(validatorId)
+    return this.buildTxData(this.sfcContract, 'unlockStake', validatorId, amount)
+  }
+
+  #validateValidatorId = (validatorId) => {
+    if (!Number.isInteger(validatorId) || validatorId <= 0) {
+      throw new Error('Validator id must be positive unsigned integer value.')
+    }
+  }
+
+  #validateRequestId = (requestId) => {
+    if (!Number.isInteger(requestId) || requestId <= 0) {
+      throw new Error('Request id must be a valid numeric identifier.')
+    }
+  }
+
+  #validateDuration = (duration) => {
+    if (!Number.isInteger(duration)) {
+      throw new Error('The lock duration must be an integer.')
+    }
+
+    if (duration > 365 * 86400) {
+      throw new Error('The lock duration must be at most 365 days.')
+    }
+  }
+}

package/src/staking/index.js

@@ -0,0 +1,2 @@
+export { MaticStaking } from './matic-staking'
+export { FantomStaking } from './fantom-staking'

package/src/staking/matic-staking.js

@@ -0,0 +1,159 @@
+import { createContract } from '@exodus/ethereum-lib'
+import { eth } from '../exodus-eth-server'
+import { retry } from '@exodus/simple-retry'
+import { bufferToHex } from '@exodus/ethereumjs-util'
+
+export const EVERSTAKE_VALIDATOR_ADDR = '0xf30cf4ed712d3734161fdaab5b1dbb49fd2d0e5c'
+export const STAKING_MANAGER_ADDR = '0x5e3ef299fddf15eaa0432e6e66473ace8c13d908'
+
+const RETRY_DELAYS = ['10s']
+
+export class MaticStaking {
+  constructor(validatorId = EVERSTAKE_VALIDATOR_ADDR, stakeManagerAddr = STAKING_MANAGER_ADDR) {
+    this.validatorShareContract = createContract(validatorId, 'maticValidatorShare')
+    this.stakingManagerContract = createContract(stakeManagerAddr, 'maticStakingManager')
+  }
+
+  buildTxData = (contract, method, ...args) => {
+    const txData = contract[method].build(...args)
+    return txData
+  }
+
+  processRead = (contract, method, ...args) => {
+    const callData = this.buildTxData(contract, method, ...args)
+    const data = {
+      data: bufferToHex(callData),
+      to: contract.address,
+      tag: 'latest',
+    }
+
+    return retry(eth.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
+  }
+
+  /**
+   * Get current checkpoint
+   * @returns {number}
+   */
+  getCurrentCheckpoint = async () => {
+    const currentEpoch = await this.processRead(this.stakingManagerContract, 'epoch')
+    return parseInt(currentEpoch, 16)
+  }
+
+  getCurrentUnbondNonce = async (address) => {
+    const result = await this.processRead(this.validatorShareContract, 'unbondNonces', address)
+    return parseInt(result, 16)
+  }
+
+  /**
+   * Get unbond info by supplying unbondNonces
+   * @param {string} address
+   * @param {number} nonce
+   * @returns {number}
+   */
+  getUnboundInfo = async (address, nonce) => {
+    let _nonce = nonce
+    if (!Number.isInteger(_nonce)) {
+      _nonce = await this.getCurrentUnbondNonce(address)
+    }
+
+    const unboundInfo = await this.processRead(
+      this.validatorShareContract,
+      'unbonds_new',
+      address,
+      _nonce
+    )
+    const [withdrawEpoch, shares] = this._removeHexPrefix(unboundInfo).match(/.{1,64}/g) || []
+    return {
+      withdrawEpoch: parseInt(withdrawEpoch, 16),
+      shares: parseInt(shares, 16),
+    }
+  }
+
+  /**
+   * Get current Liquid rewards
+   * @param {string} address
+   * @returns {number}
+   */
+  getLiquidRewards = async (address) => {
+    const currentEpoch = await this.processRead(
+      this.validatorShareContract,
+      'getLiquidRewards',
+      address
+    )
+    return parseInt(currentEpoch, 16)
+  }
+
+  /**
+   * Get total staked amount
+   * @param {string} address
+   * @returns {number}
+   */
+  getTotalStake = async (address) => {
+    const stakeInfo = await this.processRead(this.validatorShareContract, 'getTotalStake', address)
+    const [amount] = this._removeHexPrefix(stakeInfo).match(/.{1,64}/g) || []
+    return parseInt(amount, 16)
+  }
+
+  /**
+   * Get tx data of method to restake the earned rewards
+   */
+  restakeReward = () => {
+    return this.buildTxData(this.validatorShareContract, 'restake')
+  }
+
+  /**
+   * Get tx data of method to withdraw earned rewards
+   */
+  withdrawRewards = () => {
+    return this.buildTxData(this.validatorShareContract, 'withdrawRewards')
+  }
+
+  /**
+   * Get tx data of method to delegate (stake) amount to validator
+   * internally it calls method - **buyVoucher**
+   *  @param {string} param.amount
+   */
+  delegateAmount = ({ amount }) => {
+    return this.buildTxData(this.validatorShareContract, 'buyVoucher', amount, 0)
+  }
+
+  /**
+   * Get tx data of method to unstake delegated amount
+   * internally it calls - **sellVoucher_new**
+   * @param {string} param.amount
+   * @param {string} param.maximumSharesToBurn
+   * @returns {string}
+   */
+  unbond = ({ amount, maximumSharesToBurn }) => {
+    const _maximumSharesToBurn = maximumSharesToBurn || amount
+    return this.buildTxData(
+      this.validatorShareContract,
+      'sellVoucher_new',
+      amount,
+      _maximumSharesToBurn
+    )
+  }
+
+  /**
+   * Get tx data of method to claim the delegated amount by supplying nonce
+   * internally it calls method - **unstakeClaimTokens_new**
+   * @param {number} nonce
+   * @returns {string}
+   */
+  claimStake = (nonce) => {
+    return this.buildTxData(this.validatorShareContract, 'unstakeClaimTokens_new', nonce)
+  }
+
+  /**
+   * Remove 0x prefix of a hex string
+   * @param {string} str
+   * @returns {string}
+   */
+  _removeHexPrefix = (str) => {
+    if (typeof str !== 'string' || str === '') {
+      return str
+    }
+
+    return str.startsWith('0x') ? str.slice(2) : str
+  }
+}