@exodus/ethereum-plugin 2.2.3 → 2.4.0

package/CHANGELOG.md

@@ -3,6 +3,29 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [2.4.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.3.0...@exodus/ethereum-plugin@2.4.0) (2024-09-11)
+
+
+### Features
+
+* switch ethereum to ESM ([#3374](https://github.com/ExodusMovement/assets/issues/3374)) ([d3a86c3](https://github.com/ExodusMovement/assets/commit/d3a86c3202754a0e6ab988d454d3e006ec11d9e4))
+
+
+
+## [2.3.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.2.3...@exodus/ethereum-plugin@2.3.0) (2024-08-24)
+
+
+### Features
+
+* **ethereum-plugin:** bump `@exodus/web3-ethereum-utils` ([#3234](https://github.com/ExodusMovement/assets/issues/3234)) ([07329be](https://github.com/ExodusMovement/assets/commit/07329beef080533a9ebf79e434b8a5d54151e669))
+
+
+### Bug Fixes
+
+* migrate to safe report matcher for cosmos and ethereum ([#3210](https://github.com/ExodusMovement/assets/issues/3210)) ([da094a1](https://github.com/ExodusMovement/assets/commit/da094a12d3013933e03ca484d472fb84505b57b2))
+
+
+
 ## [2.2.3](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-plugin@2.2.2...@exodus/ethereum-plugin@2.2.3) (2024-08-13)
 
 **Note:** Version bump only for package @exodus/ethereum-plugin

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@exodus/ethereum-plugin",
-  "version": "2.2.3",
+  "version": "2.4.0",
   "description": "Exodus ethereum-plugin",
+  "type": "module",
   "main": "src/index.js",
   "files": [
     "src",
@@ -14,24 +15,25 @@
     "access": "restricted"
   },
   "scripts": {
-    "test": "run -T exodus-test --jest --esbuild",
-    "lint": "run -T eslint .",
+    "test": "run -T exodus-test --jest",
+    "lint": "run -T eslintc .",
     "lint:fix": "yarn lint --fix"
   },
   "dependencies": {
-    "@exodus/asset-lib": "^4.2.2",
-    "@exodus/ethereum-api": "^8.13.3",
-    "@exodus/ethereum-lib": "^5.0.1",
-    "@exodus/ethereum-meta": "^1.5.1",
-    "@exodus/web3-ethereum-utils": "^3.27.1"
+    "@exodus/asset-lib": "^5.0.0",
+    "@exodus/currency": "^2.1.3",
+    "@exodus/ethereum-api": "^8.18.1",
+    "@exodus/ethereum-lib": "^5.4.0",
+    "@exodus/ethereum-meta": "^2.0.0",
+    "@exodus/ethereumjs-util": "^7.1.0-exodus.7",
+    "@exodus/simple-retry": "^0.0.6",
+    "bn.js": "^5.2.1",
+    "minimalistic-assert": "^1.0.1"
   },
   "devDependencies": {
-    "@exodus/assets": "^9.1.1",
+    "@exodus/assets": "^11.0.0",
     "@exodus/assets-testing": "^1.0.0",
-    "@exodus/ethereumjs-util": "^7.1.0-exodus.7",
-    "@exodus/fetch": "^1.3.0",
-    "@exodus/models": "^11.0.0",
-    "lodash": "^4.17.21"
+    "@exodus/models": "^12.0.1"
   },
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Aethereum-plugin"
@@ -41,5 +43,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "71031eb3482dd28419a5b53df1ba83c45011095f"
+  "gitHead": "f35119e354e7bf4555b3bb6b453293c61e44fdd9"
 }

package/src/index.js

@@ -2,8 +2,8 @@
 import { createAssetFactory } from '@exodus/ethereum-api'
 import assetsList from '@exodus/ethereum-meta'
 
-import feeData from './fee-data'
-import { stakingConfiguration } from './staking'
+import feeData from './fee-data.js'
+import { stakingConfiguration, stakingDependencies } from './staking.js'
 
 const createAsset = createAssetFactory({
   assetsList,
@@ -13,6 +13,7 @@ const createAsset = createAssetFactory({
   erc20FuelBuffer: 1.1, // 10% more than the required fee
   fuelThreshold: '0.005',
   stakingConfiguration,
+  stakingDependencies,
   serverUrl: 'https://geth.a.exodus.io/wallet/v1/',
   confirmationsNumber: 30,
 })

package/src/staking/polygon/Staking.md

@@ -0,0 +1,71 @@
+## Staking in Polygon (MATIC)
+
+## How it works?
+
+Polygon Staking happens in the **Ethereum network**, it is implemented by a set of smart contracts deployed on the ETH mainnet.
+Staking is made by delegating the `ERC20 MATIC` token to those smart contracts which handle the `(un)staking/rewards` process and it shouldn't be confused with the Native asset in **Polygon network** (`MATIC NATIVE`).
+
+Stakers are divided into `validators`, `delegators`, and watchers (for fraud reporting).
+
+## Contracts
+
+### StakeManager contract
+
+`StakeManager` is the main contract for handling validator related activities like checkPoint signature verification, reward distribution, and stake management. Since the contract is using NFT ID as a source of ownership, change of ownership and signer won't affect anything in the system. [see](https://wiki.polygon.technology/docs/pos/contracts/stakingmanager).
+
+### ValidatorShare contract
+
+For delegation staking each validator has its own deployed **contract**, this contract has the logic to `stake/unstake` as delegators, but it also acts as an `ERC20`, this `ERC20` token is what we know as the shares token. Shares token are calculated based on the total amount staked in the contract, varying from time to time
+When delegators stake matic, they call `buyVoucher()` , the contract receives the MATIC tokens to stake (approval is needed on Matic token contract) and it calculates and mints the number of token shares that correspond to that staked amount. [see](https://wiki.polygon.technology/docs/pos/contracts/delegation).
+
+### Staking Anatomy
+
+Example taken from the docs:
+
+_Polygon supports delegation via validator shares. By using this design, it is easier to distribute rewards and slash with scale (thousands of delegators) on Ethereum contracts without much computation.
+Delegators delegate by purchasing shares of a finite pool from validators. Each validator will have their own validator share token. Let's call these fungible tokens `VATIC` for a validator `A`. As soon as a user delegates to a validator `A`, they will be issued `VATIC` based on an exchange rate of `MATIC/VATIC` pair. As users accrue value the exchange rate indicates that they can now withdraw more `MATIC` for each `VATIC` and when users get slashed, users withdraw less `MATIC` for their `VATIC`.
+Note that `MATIC` is a staking token. A delegator needs to have `MATIC` tokens to participate in the delegation.
+Initially, a delegator `D` buys tokens from validator `A` specific pool when `1 MATIC per 1 VATIC`.
+When a validator gets rewarded with more `MATIC` tokens, new tokens are added to the pool. Let's say with the current pool of `100 MATIC` tokens, `10 MATIC` rewards are added to the pool. But since the total supply of `VATIC` tokens didn't change due to rewards, the exchange rate becomes `1 MATIC per 0.9 VATIC`. Now, delegator `D` gets more `MATIC` for the same shares.
+`VATIC`: Validator specific minted validator share tokens (ERC20 tokens)_
+
+#### Rewards
+
+Delegators can do with their rewards the following:
+withdraw via `withdrawRewards()` or
+`restake` (earned rewards are put as stake in the contract via `restake()`)
+
+#### Unstaking
+
+For delegators to unstake, there are two steps:
+
+1. `sellVoucher_new()`
+2. `unstakeClaimTokens()`
+
+**Note**: there are some methods in the validator share contract with the suffix `_new`, for instance:
+`sellVoucher()` and `sellVoucher_new()` this is because the recent changes on the smart contract to support the new exit API (**unstake** and **claim** tokens)\*
+
+**sellVoucher** method calculates the token shares that correspond to the staked MATIC at that time, and burns those share tokens, it also transfers the rewards, and makes changes in the contract to update the total stake held in the contract .
+Basically it prepares the contract to let delegators withdraw their staked MATIC in a second step once the **withdrawal delay** it's ben fulfilled.
+
+#### Unstake Claim Tokens
+
+**unstakeClaimTokens** makes the actual withdraw of the staked tokens, sellVoucher does not transfer the staked MATIC back to the delegator, we need to call this function after the withdrawal delay has been fulfilled, so that delegators can get their stake amount back to their wallet.
+
+### Staking Bussines Rules
+
+All of these rules can be queried from the smart contracts, except `minimum amount to stake`, this is defined by Exodus.
+
+- **Minimum rewards to withdraw**: 1 MATIC (contract rule)
+- **Minimum amount to stake**: 1 MATIC (exodus rule)
+- **Withdrawal delay**: The amount of time delegators must wait before claiming their staked amount. Varies depending on the contract governance
+- **Withdrawal exchange rate**: The exchange rate used to convert tokens to shares and vice-versa. Varies depending on the number of MATIC in the withdraw pool share (affected by the earned rewards).
+- **Unstaking period**: immediately, but staked MATIC tokens are not available to be withdrawn before withdrawal delay
+- **Claim unstaked tokens**: after 3-4 days has passed since unstaked was called, the unstaked tokens can be claimed by the delegator.
+
+Useful resources:
+
+[Polygon docs](https://wiki.polygon.technology/docs/pos/polygon-architecture/)
+[Polygon Staking](https://wiki.polygon.technology/docs/pos/contracts/delegation)
+[StakeManager contract](https://github.com/maticnetwork/contracts/blob/main/contracts/staking/stakeManager/StakeManager.sol)
+[Validator share contract](https://github.com/maticnetwork/contracts/blob/main/contracts/staking/stakeManager/StakeManager.sol)

package/src/staking/polygon/account-state.js

@@ -0,0 +1,12 @@
+export const stakingAccountState = ({ currency }) => ({
+  isDelegating: false,
+  isUndelegateInProgress: false,
+  canClaimUndelegatedBalance: false,
+  minRewardsToWithdraw: currency.defaultUnit(1),
+  minDelegateAmount: currency.defaultUnit(1),
+  unclaimedUndelegatedBalance: currency.ZERO,
+  delegatedBalance: currency.ZERO,
+  rewardsBalance: currency.ZERO,
+  withdrawable: currency.ZERO,
+  unbondNonce: '0',
+})

package/src/staking/polygon/api.js

@@ -0,0 +1,201 @@
+import { createContract } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs-util'
+import { retry } from '@exodus/simple-retry'
+import BN from 'bn.js'
+
+import { mainnetContracts } from './contracts/index.js'
+
+const RETRY_DELAYS = ['10s']
+
+class StakingServer {
+  constructor({ asset, server, contracts = mainnetContracts }) {
+    this.asset = asset
+    // harcoded exchange rate from the validator share contract
+    // in order to calculate claim unstake amount off-chain
+    this.EXCHANGE_RATE_PRECISION = new BN(10).pow(new BN(29))
+    this.validatorShareContract = createContract(
+      contracts.VALIDATOR_SHARES_CONTRACT_ADDR,
+      'maticValidatorShare'
+    )
+    this.stakingManagerContract = createContract(
+      contracts.STAKING_MANAGER_ADDR,
+      'maticStakingManager'
+    )
+    this.polygonContract = createContract(contracts.TOKEN_CONTRACT, 'polygon')
+    this.server = server
+  }
+
+  buildTxData = (contract, method, ...args) => {
+    return contract[method].build(...args)
+  }
+
+  callReadFunctionContract = (contract, method, ...args) => {
+    const callData = this.buildTxData(contract, method, ...args)
+    const data = {
+      data: bufferToHex(callData),
+      to: contract.address,
+      tag: 'latest',
+    }
+
+    const eth = this.server
+    return retry(eth.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
+  }
+
+  getWithdrawalDelay = async () => {
+    const withdrawalDelay = await this.callReadFunctionContract(
+      this.stakingManagerContract,
+      'withdrawalDelay'
+    )
+    return toBN(withdrawalDelay)
+  }
+
+  getMinRewardsToWithdraw = async () => {
+    const minRewardsToWithdraw = await this.callReadFunctionContract(
+      this.validatorShareContract,
+      'minAmount'
+    )
+    return this.asset.currency.baseUnit(minRewardsToWithdraw)
+  }
+
+  /**
+   * A checkpoint is an epoch value that increments in the contract, every epoch is
+   * stored in a list and points the events that happened in that epoch. (timeline)
+   */
+  getCurrentCheckpoint = async () => {
+    const currentEpoch = await this.callReadFunctionContract(this.stakingManagerContract, 'epoch')
+    return toBN(currentEpoch)
+  }
+
+  /**
+   * Unbond is a struct in the staking contract that holds the number of shares and
+   * the withdrawEpoch for a delegator (used when delegators unstaked their tokens)
+   * @returns {number}
+   */
+  getUnboundInfo = async (address, nonce) => {
+    let _nonce = nonce
+    if (!Number.isInteger(_nonce)) {
+      _nonce = await this.getCurrentUnbondNonce(address)
+    }
+
+    const unboundInfo = await this.callReadFunctionContract(
+      this.validatorShareContract,
+      'unbonds_new',
+      address,
+      _nonce
+    )
+
+    const [shares, withdrawEpoch] = splitIn32BytesArray(unboundInfo)
+    return {
+      withdrawEpoch: toBN(withdrawEpoch),
+      shares: toBN(shares),
+    }
+  }
+
+  /**
+   * UnbondNonce is a counter stored in the contract that tracks each time a delegator unstakes
+   * @param address delegator address
+   * @returns current unbonded nonce
+   */
+  getCurrentUnbondNonce = async (address) => {
+    const unbondNonce = await this.callReadFunctionContract(
+      this.validatorShareContract,
+      'unbondNonces',
+      address
+    )
+    return parseInt(unbondNonce, 16)
+  }
+
+  getLiquidRewards = async (address) => {
+    const liquidRewards = await this.callReadFunctionContract(
+      this.validatorShareContract,
+      'getLiquidRewards',
+      address
+    )
+    return this.asset.currency.baseUnit(liquidRewards)
+  }
+
+  getTotalStake = async (address) => {
+    const stakeInfo = await this.callReadFunctionContract(
+      this.validatorShareContract,
+      'getTotalStake',
+      address
+    )
+    const [amount] = splitIn32BytesArray(stakeInfo)
+    return this.asset.currency.baseUnit(toBN(amount).toString())
+  }
+
+  getWithdrawExchangeRate = async () => {
+    const withdrawExchangeRate = await this.callReadFunctionContract(
+      this.validatorShareContract,
+      'withdrawExchangeRate'
+    )
+
+    return toBN(withdrawExchangeRate)
+  }
+
+  /**
+   * Approves StakeManager contract for withdrawing {amount} in Matic tokens
+   * when users stakes.
+   * This function needs to be called before calling delegate function so that staking
+   * can properly work
+   * This also partially address the front running attack on ERC20 approve function:
+   * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/f959d7e4e6ee0b022b41e5b644c79369869d8411/contracts/token/ERC20/ERC20.sol#L165-L206
+   * @param amount Matic tokens to be approved for StakeManager to withdraw (polygon currency)
+   */
+  approveStakeManager = (amount) => {
+    return this.buildTxData(
+      this.polygonContract,
+      'increaseAllowance',
+      this.stakingManagerContract.address,
+      amount.toBaseString()
+    )
+  }
+
+  restakeReward = () => {
+    return this.buildTxData(this.validatorShareContract, 'restake')
+  }
+
+  withdrawRewards = () => {
+    return this.buildTxData(this.validatorShareContract, 'withdrawRewards')
+  }
+
+  delegate = ({ amount }) => {
+    return this.buildTxData(this.validatorShareContract, 'buyVoucher', amount.toBaseString(), '0')
+  }
+
+  undelegate = ({ amount, maximumSharesToBurn }) => {
+    const _maximumSharesToBurn = maximumSharesToBurn || amount
+    return this.buildTxData(
+      this.validatorShareContract,
+      'sellVoucher_new',
+      amount.toBaseString(),
+      _maximumSharesToBurn.toBaseString()
+    )
+  }
+
+  /**
+   * @param {number} unbondNonce the unbond nonce from where delegator claim its staked tokens
+   */
+  claimUndelegatedBalance = ({ unbondNonce }) => {
+    return this.buildTxData(this.validatorShareContract, 'unstakeClaimTokens_new', unbondNonce)
+  }
+}
+
+// see arguments encoding standard (padded 32 bytes)
+// https://docs.soliditylang.org/en/v0.8.15/abi-spec.html?highlight=abi.encode#function-selector-and-argument-encoding
+const splitIn32BytesArray = (output) => removeHexPrefix(output).match(/[\da-f]{1,64}/gi) || []
+
+const toBN = (str) => new BN(removeLeadingZeroes(removeHexPrefix(str)), 16)
+
+const removeLeadingZeroes = (str) => str.replace(/^0+/, '')
+
+const removeHexPrefix = (str) => {
+  if (typeof str !== 'string' || str === '') {
+    return str
+  }
+
+  return str.startsWith('0x') ? str.slice(2) : str
+}
+
+export const stakingServerFactory = ({ asset, contracts, server }) =>
+  new StakingServer({ asset, contracts, server })

package/src/staking/polygon/contracts/index.js

@@ -0,0 +1,12 @@
+export const mainnetContracts = {
+  VALIDATOR_SHARES_CONTRACT_ADDR: '0xf30cf4ed712d3734161fdaab5b1dbb49fd2d0e5c',
+  STAKING_MANAGER_ADDR: '0x5e3ef299fddf15eaa0432e6e66473ace8c13d908',
+  TOKEN_CONTRACT: '0x7d1afa7b718fb893db30a3abc0cfc608aacfebb0',
+}
+
+export const methodIds = {
+  DELEGATE: '0x6ab15071', // buyVoucher(uint256 _amount, uint256 _minSharesToMint)
+  UNDELEGATE: '0xc83ec04d', // sellVoucher_new(uint256 claimAmount, uint256 maximumSharesToBurn)
+  CLAIM_REWARD: '0xc7b8981c', // withdrawRewards()
+  CLAIM_UNDELEGATE: '0xe97fddc2', // unstakeClaimTokens_new(uint256 unbondNonce)
+}

package/src/staking/polygon/index.js

@@ -0,0 +1,27 @@
+import { tokens } from '@exodus/ethereum-meta'
+
+import { stakingAccountState } from './account-state.js'
+import { stakingServerFactory } from './api.js'
+import { mainnetContracts, methodIds } from './contracts/index.js'
+import { stakingServiceFactory } from './service.js'
+import { txUtilsFactory } from './staking-utils.js'
+
+const polygon = tokens.find(({ name: tokenName }) => tokenName === 'polygon')
+
+export const polygonStakingConfig = {
+  accountStateExtraData: stakingAccountState(polygon),
+  features: {
+    stake: true,
+    unstake: true,
+    claimUnstaked: true,
+    claimRewards: true,
+  },
+  contracts: mainnetContracts,
+  methodIds,
+}
+
+export const polygonStakingDeps = {
+  txUtilsFactory,
+  stakingServiceFactory,
+  stakingServerFactory,
+}

package/src/staking/polygon/service.js

@@ -0,0 +1,467 @@
+import { isNumberUnit } from '@exodus/currency'
+import { estimateGasLimit, stakingProviderClientFactory } from '@exodus/ethereum-api'
+import BN from 'bn.js'
+
+export function stakingServiceFactory({ assetClientInterface, server, stakingServer }) {
+  const stakingProvider = stakingProviderClientFactory()
+
+  function amountToCurrency({ asset, amount }) {
+    return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
+  }
+
+  async function getStakeAssets() {
+    const { polygon: asset, ethereum: feeAsset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: 'ethereum', // Polygon token lives in ETH network
+    })
+    return { asset, feeAsset }
+  }
+
+  async function approveDelegateAmount({ walletAccount, amount } = {}) {
+    const { asset } = await getStakeAssets()
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+
+    amount = amountToCurrency({ asset, amount })
+
+    const txApproveData = await stakingServer.approveStakeManager(amount)
+    const { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress,
+      asset.contracts.TOKEN_CONTRACT,
+      txApproveData
+    )
+
+    return prepareAndSendTx({
+      walletAccount,
+      waitForConfirmation: true,
+      to: asset.contracts.TOKEN_CONTRACT,
+      txData: txApproveData,
+      gasPrice,
+      gasLimit,
+      fee,
+    })
+  }
+
+  async function delegate({ walletAccount, amount } = {}) {
+    const { asset } = await getStakeAssets()
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+
+    amount = amountToCurrency({ asset, amount })
+
+    // const txApproveData = await stakingServer.approveStakeManager(amount)
+    // let { gasPrice, gasLimit, fee } = await estimateTxFee(
+    //   delegatorAddress,
+    //   contracts.TOKEN_CONTRACT,
+    //   txApproveData
+    // )
+    // await prepareAndSendTx({
+    //   walletAccount,
+    //   waitForConfirmation: true,
+    //   to: contracts.TOKEN_CONTRACT,
+    //   txData: txApproveData,
+    //   gasPrice,
+    //   gasLimit,
+    //   fee,
+    // })
+
+    const txDelegateData = await stakingServer.delegate({ amount })
+    const { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress,
+      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      txDelegateData
+    )
+
+    const txId = await prepareAndSendTx({
+      walletAccount,
+      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      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 { asset } = await getStakeAssets()
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+
+    amount = amountToCurrency({ asset, amount })
+
+    const txUndelegateData = await stakingServer.undelegate({ amount })
+    const { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress.toLowerCase(),
+      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      txUndelegateData
+    )
+    return prepareAndSendTx({
+      walletAccount,
+      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      txData: txUndelegateData,
+      gasPrice,
+      gasLimit,
+      fee,
+    })
+  }
+
+  async function claimRewards({ walletAccount } = {}) {
+    const { asset } = await getStakeAssets()
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+
+    const txWithdrawRewardsData = await stakingServer.withdrawRewards()
+    const { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress,
+      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      txWithdrawRewardsData
+    )
+    return prepareAndSendTx({
+      walletAccount,
+      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      txData: txWithdrawRewardsData,
+      gasPrice,
+      gasLimit,
+      fee,
+    })
+  }
+
+  async function claimUndelegatedBalance({ walletAccount, unbondNonce } = {}) {
+    const { asset } = await getStakeAssets()
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+
+    const { currency } = asset
+    const unstakedClaimInfo = await fetchUnstakedClaimInfo({
+      stakingServer,
+      delegator: delegatorAddress,
+    })
+
+    const { unclaimedUndelegatedBalance } = await getUnstakedUnclaimedInfo({
+      stakingServer,
+      currency,
+      delegator: delegatorAddress,
+      ...unstakedClaimInfo,
+    })
+
+    const txClaimUndelegatedData = await stakingServer.claimUndelegatedBalance({ unbondNonce })
+    const { gasPrice, gasLimit, fee } = await estimateTxFee(
+      delegatorAddress,
+      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      txClaimUndelegatedData
+    )
+    const txId = await prepareAndSendTx({
+      walletAccount,
+      to: asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      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 = stakingServer[operation]
+
+    if (!delegateOperation) {
+      return
+    }
+
+    const { asset } = await getStakeAssets()
+    const address = await assetClientInterface.getReceiveAddress({
+      assetName: asset.name,
+      walletAccount,
+    })
+    const delegatorAddress = address.toLowerCase()
+
+    const { amount } = args
+    if (amount) {
+      args = { ...args, amount: amountToCurrency({ asset, amount }) }
+    }
+
+    const operationTxData = await delegateOperation({ ...args, walletAccount })
+    const { fee } = await estimateTxFee(
+      delegatorAddress,
+      asset.contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+      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 { feeAsset } = await getStakeAssets()
+    const erc20ApproveGas = 4900
+    const delegateGas = 240_000
+    const gasPrice = parseInt(await server.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: feeAsset.currency.baseUnit(fee.toString()),
+    }
+  }
+
+  async function estimateTxFee(from, to, txInput, gasPrice = '0x0') {
+    const { feeAsset } = await getStakeAssets()
+
+    const amount = feeAsset.currency.ZERO
+    const gasLimit = await estimateGasLimit(
+      feeAsset,
+      from,
+      to,
+      amount, // staking contracts does not require ETH amount to interact with
+      txInput,
+      gasPrice
+    )
+
+    if (gasPrice === '0x0') {
+      gasPrice = await server.gasPrice()
+    }
+
+    gasPrice = parseInt(gasPrice, 16)
+    const fee = new BN(gasPrice).mul(new BN(gasLimit))
+
+    return {
+      gasLimit,
+      gasPrice: feeAsset.currency.baseUnit(gasPrice),
+      fee: feeAsset.currency.baseUnit(fee.toString()),
+    }
+  }
+
+  async function prepareAndSendTx({
+    walletAccount,
+    to,
+    txData: txInput,
+    gasPrice,
+    gasLimit,
+    fee,
+    waitForConfirmation = false,
+  } = {}) {
+    const { asset, feeAsset } = await getStakeAssets()
+
+    const sendTxArgs = {
+      asset: feeAsset,
+      walletAccount,
+      address: to,
+      amount: feeAsset.currency.ZERO,
+      // used in desktop,
+      // remove once, txSend is unified
+      receiver: {
+        address: to,
+        amount: feeAsset.currency.ZERO,
+      },
+      options: {
+        shouldLog: true,
+        txInput,
+        gasPrice,
+        gasLimit,
+        feeAmount: fee,
+      },
+      waitForConfirmation,
+    }
+
+    const { txId } = await asset.api.sendTx(sendTxArgs)
+
+    return txId
+  }
+
+  const getStakingInfo = getPolygonStakingInfo({ assetClientInterface, stakingServer })
+
+  return {
+    approveDelegateAmount,
+    delegate,
+    undelegate,
+    claimRewards,
+    claimUndelegatedBalance,
+    getStakingInfo,
+    estimateDelegateTxFee,
+    estimateDelegateOperation,
+  }
+}
+
+async function fetchUnstakedClaimInfo({ stakingServer, delegator }) {
+  const [unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate] = await Promise.all([
+    stakingServer.getCurrentUnbondNonce(delegator),
+    stakingServer.getWithdrawalDelay(),
+    stakingServer.getCurrentCheckpoint(),
+    stakingServer.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({
+  stakingServer,
+  currency,
+  delegator,
+  unbondNonce,
+  currentEpoch,
+  withdrawalDelay,
+  withdrawExchangeRate,
+}) {
+  const { withdrawEpoch, shares } = await stakingServer.getUnboundInfo(delegator, unbondNonce)
+  const exchangeRatePrecision = stakingServer.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({ stakingServer, delegator, currency }) {
+  const [minRewardsToWithdraw, rewardsBalance] = await Promise.all([
+    stakingServer.getMinRewardsToWithdraw(),
+    stakingServer.getLiquidRewards(delegator),
+  ])
+  const withdrawable = rewardsBalance.sub(minRewardsToWithdraw).gte(currency.ZERO)
+    ? rewardsBalance
+    : currency.ZERO
+
+  return {
+    rewardsBalance,
+    minRewardsToWithdraw,
+    withdrawable,
+  }
+}
+
+export function getPolygonStakingInfo({ assetClientInterface, stakingServer }) {
+  return async function ({ address }) {
+    const { polygon: asset } = await assetClientInterface.getAssetsForNetwork({
+      baseAssetName: 'ethereum', // Polygon token lives in ETH network
+    })
+    const { currency } = asset
+    const delegator = address.toLowerCase()
+    const [
+      delegatedBalance,
+      { rewardsBalance, minRewardsToWithdraw, withdrawable },
+      { unbondNonce, withdrawalDelay, currentEpoch, withdrawExchangeRate },
+    ] = await Promise.all([
+      stakingServer.getTotalStake(delegator),
+      fetchRewardsInfo({ stakingServer, delegator, currency }),
+      fetchUnstakedClaimInfo({ stakingServer, delegator }),
+    ])
+    const minDelegateAmount = currency.defaultUnit(1)
+    const isDelegating = !delegatedBalance.isZero
+
+    const unclaimedUndelegatedInfo = await getUnstakedUnclaimedInfo({
+      stakingServer,
+      currency,
+      delegator,
+      unbondNonce,
+      currentEpoch,
+      withdrawalDelay,
+      withdrawExchangeRate,
+    })
+
+    return {
+      rewardsBalance,
+      withdrawable,
+      unbondNonce,
+      isDelegating,
+      delegatedBalance,
+      minRewardsToWithdraw,
+      minDelegateAmount,
+      ...unclaimedUndelegatedInfo,
+    }
+  }
+}

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

@@ -0,0 +1,117 @@
+import assert from 'minimalistic-assert'
+
+import { mainnetContracts, methodIds as methodIds_ } from './contracts/index.js'
+import { txFiltersFactory } from './tx-filters/index.js'
+
+/**
+ * Used in ethereum-hooks to extract the final tx amount and the staking type
+ *
+ * tx.amount is altered for staking txs
+ *
+ * - amount is set to ZERO
+ * - rewards are derived from the tx (only applicable to Polygon. Ethereum has more complicated rewards distribution)
+ * -
+ */
+function getStakingTxDetailsFactory({
+  isDelegateTx,
+  isUndelegateTx,
+  isClaimUndelegateTx,
+  decodeStakingTxAmount,
+  calculateRewardsFromStakeTx,
+}) {
+  return function ({ tx, currency }) {
+    if (
+      ['delegate', 'undelegate', 'claimUndelegate'].some((stakingType) => tx.data?.[stakingType]) &&
+      tx.coinAmount.isZero
+    ) {
+      return
+    }
+
+    const txAmount = tx.coinAmount.toDefaultString()
+
+    if (isDelegateTx(tx)) {
+      const delegate = currency.baseUnit(decodeStakingTxAmount(tx)).toDefaultString()
+      // MATIC returned in unstake tx is always reward
+      const rewards = calculateRewardsFromStakeTx({ tx, currency })
+      return { delegate, txAmount, ...(rewards ? { rewards } : {}) }
+    }
+
+    if (isUndelegateTx(tx)) {
+      const undelegate = currency.baseUnit(decodeStakingTxAmount(tx)).toDefaultString()
+      // MATIC returned in unstake tx is always reward
+      const rewards = txAmount
+      return { undelegate, txAmount, rewards }
+    }
+
+    if (isClaimUndelegateTx(tx)) {
+      return { claimUndelegate: txAmount, txAmount }
+    }
+
+    // not a staking tx
+  }
+}
+
+const calculateRewardsFromStakeTxFactory =
+  ({ decodeStakingTxAmount }) =>
+  ({ tx, currency }) => {
+    const stakedAmount = currency.baseUnit(decodeStakingTxAmount(tx))
+    const { reward } = tx.data
+    // stake tx might have rewards in it,
+    // i.e: https://etherscan.io/tx/0x0a81d266109034a3a70c6f1b9601c105d8caebbd0de652a0619344f9559ae4fa
+    // thus reward = txInputAmount(amount to stake) - tx.coinAmount
+    // tx.coinAmount is already computed from monitor; incoming - outgoing ERC20 token txs
+    const stakeTxContainsReward = !stakedAmount.equals(tx.coinAmount.abs())
+
+    if (reward) {
+      // cache rewards
+      return currency.baseUnit(reward)
+    }
+
+    if (stakeTxContainsReward) {
+      const txAmount = stakedAmount.sub(tx.coinAmount.abs()).abs()
+      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only -- TODO: Fix this the next time the file is edited.
+      return txAmount.toDefaultString()
+    }
+  }
+
+const decodeStakingTxAmountFactory =
+  ({ validatorShareContract }) =>
+  (tx) => {
+    const {
+      data: { data: txInput },
+    } = tx
+
+    const {
+      values: [amount], // stake or unstake amount
+    } = validatorShareContract.decodeInput(txInput)
+
+    return amount
+  }
+
+export const txUtilsFactory = ({
+  stakingServer,
+  contracts = mainnetContracts,
+  methodIds = methodIds_,
+}) => {
+  assert(stakingServer, 'stakingServer is required')
+
+  const { isDelegateTx, isUndelegateTx, isClaimUndelegateTx, getStakingTxLogFilter } =
+    txFiltersFactory({ contracts, methodIds })
+
+  const { validatorShareContract } = stakingServer
+  const decodeStakingTxAmount = decodeStakingTxAmountFactory({ validatorShareContract })
+  const calculateRewardsFromStakeTx = calculateRewardsFromStakeTxFactory({ decodeStakingTxAmount })
+
+  const getStakingTxDetails = getStakingTxDetailsFactory({
+    isDelegateTx,
+    isUndelegateTx,
+    isClaimUndelegateTx,
+    decodeStakingTxAmount,
+    calculateRewardsFromStakeTx,
+  })
+
+  return {
+    getStakingTxLogFilter,
+    getStakingTxDetails,
+  }
+}

package/src/staking/polygon/tx-filters/index.js

@@ -0,0 +1,34 @@
+export const txFiltersFactory = ({ contracts, methodIds }) => {
+  const isAssetTx = ({ coinName }) => coinName === 'polygon'
+  const isDelegateTx = (tx) =>
+    isAssetTx(tx) &&
+    tx.to === contracts.STAKING_MANAGER_ADDR &&
+    tx.data?.methodId === methodIds.DELEGATE
+  const isUndelegateTx = (tx) =>
+    isAssetTx(tx) &&
+    tx.from[0] === contracts.STAKING_MANAGER_ADDR &&
+    tx.data?.methodId === methodIds.UNDELEGATE
+  const isRewardTx = (tx) =>
+    isAssetTx(tx) &&
+    tx.from[0] === contracts.STAKING_MANAGER_ADDR &&
+    tx.data?.methodId === methodIds.CLAIM_REWARD
+  const isClaimUndelegateTx = (tx) =>
+    isAssetTx(tx) &&
+    tx.from[0] === contracts.STAKING_MANAGER_ADDR &&
+    tx.data?.methodId === methodIds.CLAIM_UNDELEGATE
+
+  const isStakingTx = (tx) => tx.to === contracts.EVERSTAKE_VALIDATOR_CONTRACT_ADDR
+
+  const getStakingTxLogFilter = (tx) =>
+    isDelegateTx(tx) || isClaimUndelegateTx(tx) || isUndelegateTx(tx)
+
+  return {
+    isAssetTx,
+    isStakingTx,
+    isDelegateTx,
+    isUndelegateTx,
+    isClaimUndelegateTx,
+    isRewardTx,
+    getStakingTxLogFilter,
+  }
+}

package/src/staking.js

@@ -1,26 +1,13 @@
 import { ethStakeAccountState } from '@exodus/ethereum-lib'
-import { asset, tokens } from '@exodus/ethereum-meta'
+import { asset } from '@exodus/ethereum-meta'
 
-const polygon = tokens.find(({ name: tokenName }) => tokenName === 'polygon')
-
-export const polygonStakeAccountState = ({ currency }) => ({
-  isDelegating: false,
-  // Unstaking takes ~3-4 days, after that, user needs to
-  // claim the unstaked amount (initial staked amount)
-  isUndelegateInProgress: false,
-  canClaimUndelegatedBalance: false,
-  minRewardsToWithdraw: currency.defaultUnit(1),
-  minDelegateAmount: currency.defaultUnit(1),
-  unclaimedUndelegatedBalance: currency.ZERO,
-  delegatedBalance: currency.ZERO,
-  rewardsBalance: currency.ZERO,
-  withdrawable: currency.ZERO,
-  unbondNonce: '0',
-})
+import { polygonStakingConfig, polygonStakingDeps } from './staking/polygon/index.js'
 
 export const stakingConfiguration = {
   ethereum: { accountStateExtraData: ethStakeAccountState(asset) },
-  polygon: {
-    accountStateExtraData: polygonStakeAccountState(polygon),
-  },
+  polygon: polygonStakingConfig,
+}
+
+export const stakingDependencies = {
+  polygon: polygonStakingDeps,
 }