@exodus/ethereum-api 9.0.0-alpha.2 → 9.0.0

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

@@ -1,20 +1,291 @@
-import { EthereumStaking } from './api'
+import NumberUnit from '@exodus/currency'
+import { parseUnsignedTx } from '@exodus/ethereum-lib'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import assert from 'minimalistic-assert'
+
+import { simulateTransactions as simulateEthereumTransactions } from '../../simulation/simulate-transactions.js'
+import { EthereumStaking, UNSTAKE_DEFAULTS } from './api.js'
+import { simulateEverstakeUnstake } from './everstake.js'
 
 const { DELEGATE, UNSTAKE, UNSTAKE_PENDING, CLAIM_UNSTAKE } = EthereumStaking.METHODS_IDS
 
 const STAKING_MANAGER_CONTRACTS = new Set([
   EthereumStaking.addresses.ethereum.EVERSTAKE_ADDRESS_CONTRACT_POOL.toLowerCase(),
   EthereumStaking.addresses.ethereumgoerli.EVERSTAKE_ADDRESS_CONTRACT_POOL.toLowerCase(),
-  EthereumStaking.addresses.ethereumholesky.EVERSTAKE_ADDRESS_CONTRACT_POOL.toLowerCase(),
 ])
 
+const METHOD_ID_CHAR_LENGTH = 10
+const FIRST_UINT256_END = METHOD_ID_CHAR_LENGTH + 64
+
 export const isEthereumStakingTx = ({ coinName }) =>
-  ['ethereum', 'ethereumgoerli', 'ethereumholesky'].includes(coinName)
+  ['ethereum', 'ethereumgoerli'].includes(coinName)
+export const isEthereumStakingPoolContract = (address) =>
+  typeof address === 'string' && STAKING_MANAGER_CONTRACTS.has(address.toLowerCase())
 export const isEthereumDelegate = (tx) =>
-  isEthereumStakingTx(tx) && STAKING_MANAGER_CONTRACTS.has(tx.to) && tx.data?.methodId === DELEGATE
+  isEthereumStakingTx(tx) &&
+  ((STAKING_MANAGER_CONTRACTS.has(tx.to) && tx.data?.methodId === DELEGATE) ||
+    tx.data?.delegate === true ||
+    typeof tx.data?.delegate === 'string')
 export const isEthereumUndelegatePending = (tx) =>
   isEthereumStakingTx(tx) && tx.data?.methodId === UNSTAKE_PENDING
 export const isEthereumUndelegate = (tx) =>
   (isEthereumStakingTx(tx) && tx.data?.methodId === UNSTAKE) || isEthereumUndelegatePending(tx)
 export const isEthereumClaimUndelegate = (tx) =>
   isEthereumStakingTx(tx) && tx.data?.methodId === CLAIM_UNSTAKE
+
+export function decodeEthereumStakingFirstUintArg(transactionData) {
+  const txInputHex =
+    (Buffer.isBuffer(transactionData) ? bufferToHex(transactionData) : transactionData) || '0x'
+  assert(typeof txInputHex === 'string', 'expected string transactionData')
+  assert(
+    txInputHex.length >= FIRST_UINT256_END,
+    'expected staking transaction calldata with first uint256 arg'
+  )
+
+  return BigInt(`0x${txInputHex.slice(METHOD_ID_CHAR_LENGTH, FIRST_UINT256_END)}`)
+}
+
+export async function ethereumUnstakePendingOptimisticSideEffectTxLogs({
+  asset: baseAsset,
+  walletAccount,
+  feeAmount,
+  unstakePendingTxId,
+  nonce,
+  estimatedUnstakePendingGasLimit,
+  tipGasPrice,
+  transactionData,
+  txToAddress,
+  date,
+  bundleId,
+}) {
+  let amount
+  try {
+    const decodedAmount = decodeEthereumStakingFirstUintArg(transactionData)
+    amount = baseAsset.currency.baseUnit(decodedAmount.toString())
+  } catch (e) {
+    console.warn(
+      'Could not decode ETH unstakePending transaction data:',
+      unstakePendingTxId,
+      e.message,
+      transactionData
+    )
+    return []
+  }
+
+  return [
+    {
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [
+        {
+          confirmations: 0,
+          feeAmount,
+          feeCoinName: baseAsset.feeAsset.name,
+          selfSend: false,
+          to: txToAddress,
+          txId: unstakePendingTxId,
+          data: {
+            gasLimit: estimatedUnstakePendingGasLimit,
+            nonce,
+            ...(tipGasPrice && { tipGasPrice: tipGasPrice.toBaseString() }),
+            methodId: UNSTAKE_PENDING,
+            ...(bundleId ? { bundleId } : {}),
+          },
+          coinAmount: amount,
+          coinName: baseAsset.name,
+          currencies: {
+            [baseAsset.name]: baseAsset.currency,
+            [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+          },
+          date,
+        },
+      ],
+    },
+  ]
+}
+
+export async function ethereumUnstakeOptimisticSideEffectTxLogs({
+  asset: baseAsset,
+  walletAccount,
+  feeAmount,
+  unstakeTxId,
+  nonce,
+  estimatedUnstakeGasLimit,
+  tipGasPrice,
+  transactionData,
+  txToAddress,
+  fromAddress,
+  allowedInterchangeNum = UNSTAKE_DEFAULTS.allowedInterchangeNum,
+  date,
+  bundleId,
+}) {
+  let amountEth
+  try {
+    const decodedAmountWei = decodeEthereumStakingFirstUintArg(transactionData)
+    amountEth = baseAsset.currency.baseUnit(decodedAmountWei.toString()).toDefaultString()
+  } catch (e) {
+    console.warn(
+      'Could not decode ETH unstake transaction data:',
+      unstakeTxId,
+      e.message,
+      transactionData
+    )
+    return []
+  }
+
+  const result = await simulateEverstakeUnstake({
+    address: fromAddress,
+    amount: amountEth,
+    allowedInterchangeNum,
+  })
+
+  if (!result || result.instantReturnEth <= 0) return []
+
+  const instantAmount = baseAsset.currency.defaultUnit(String(result.instantReturnEth))
+
+  return [
+    {
+      assetName: baseAsset.name,
+      walletAccount,
+      txs: [
+        {
+          confirmations: 0,
+          feeAmount,
+          feeCoinName: baseAsset.feeAsset.name,
+          selfSend: false,
+          to: txToAddress,
+          txId: unstakeTxId,
+          data: {
+            gasLimit: estimatedUnstakeGasLimit,
+            nonce,
+            ...(tipGasPrice && { tipGasPrice: tipGasPrice.toBaseString() }),
+            methodId: UNSTAKE,
+            ...(bundleId ? { bundleId } : {}),
+          },
+          coinAmount: instantAmount,
+          coinName: baseAsset.name,
+          currencies: {
+            [baseAsset.name]: baseAsset.currency,
+            [baseAsset.feeAsset.name]: baseAsset.feeAsset.currency,
+          },
+          date,
+        },
+      ],
+    },
+  ]
+}
+
+export function buildSimulationRequest({ asset, unsignedTx, gasPrice }) {
+  const parsed = parseUnsignedTx({ asset, unsignedTx })
+  const chainId = unsignedTx.txData?.chainId
+  const from = unsignedTx.txMeta?.fromAddress
+  const to = unsignedTx.txMeta?.toAddress
+
+  assert(gasPrice instanceof NumberUnit, 'expected NumberUnit gasPrice')
+  assert(Number.isInteger(chainId), 'expected integer chainId')
+  assert(typeof from === 'string' && from, 'expected string fromAddress')
+  assert(typeof to === 'string' && to, 'expected string toAddress')
+
+  return {
+    chainId,
+    from,
+    to,
+    gas: `0x${parsed.gasLimit.toString(16)}`,
+    gasPrice: `0x${BigInt(gasPrice.toBaseString()).toString(16)}`,
+    value: `0x${BigInt(parsed.value.toBaseString()).toString(16)}`,
+    data: `0x${parsed.data?.toString('hex')}`,
+    nonce: `0x${parsed.nonce.toString(16)}`,
+  }
+}
+
+export async function simulateUndelegateTransactions({
+  asset,
+  txSteps,
+  senderAddress,
+  gasPrice,
+  blockNumber,
+  revertOnSimulationError,
+}) {
+  const transactions = Object.values(txSteps)
+    .filter((txStep) => txStep.unsignedTx)
+    .map((txStep) =>
+      buildSimulationRequest({ asset: asset.baseAsset, unsignedTx: txStep.unsignedTx, gasPrice })
+    )
+
+  if (transactions.length === 0) return
+
+  const simulationResponse = await simulateEthereumTransactions({
+    asset: asset.baseAsset,
+    baseAssetName: asset.baseAsset.name,
+    origin: 'exodus-staking',
+    senderAddress,
+    ...(blockNumber === undefined ? undefined : { blockNumber }),
+    transactions,
+  })
+
+  if (simulationResponse?.warnings?.length || simulationResponse?.metadata?.humanReadableError) {
+    if (revertOnSimulationError) {
+      const err = new Error('StakingEthUndelegateSimulationError')
+      err.message = simulationResponse?.metadata?.humanReadableError
+      err.reason = `warnings: ${JSON.stringify(simulationResponse?.warnings)}`
+      err.hint = 'undelegate-eth-simulation-error'
+      throw err
+    } else {
+      console.warn(
+        'Simulation for ETH undelegate returned issues',
+        simulationResponse?.metadata?.humanReadableError
+      )
+    }
+  }
+
+  // Validate undelegatePending simulation results.
+  //
+  // Pass: every ETH entry in willReceive has a parseable balance and their
+  //       sum is positive (i.e. we are actually receiving ETH back).
+  // Fail: any ETH entry has a malformed balance (shape error), or the
+  //       summed ETH is zero/negative (no refund, or only non-ETH entries).
+  //
+  // Our on-chain analysis showed an apparent invariant: successful
+  // unstakePending() calls return exactly the input amount. We intentionally
+  // do not enforce that here because we were not able to prove it via
+  // simulation alone and there may be an off-chain component involved.
+  //
+  // When there's no pending balance (only unstake with
+  // allowedInterchangeNum=0), nothing may come back immediately — that's
+  // valid and we skip the check.
+  if (txSteps.undelegatePending.plan?.amount?.isPositive) {
+    const { balanceChanges = Object.create(null) } = simulationResponse || Object.create(null)
+
+    const asArray = (v) => (Array.isArray(v) ? v : [])
+    let invalidEthReceiveValue = false
+    let sumEthReceive = BigInt(0)
+
+    for (const receive of asArray(balanceChanges.willReceive)) {
+      const isEth = receive?.asset?.symbol === 'ETH' || receive?.asset?.name === 'Ether'
+      if (!isEth) continue
+
+      try {
+        sumEthReceive += BigInt(receive.balance.toBaseString())
+      } catch {
+        invalidEthReceiveValue = true
+      }
+    }
+
+    if (invalidEthReceiveValue || sumEthReceive <= BigInt(0)) {
+      if (revertOnSimulationError) {
+        const err = new Error('StakingEthUndelegateSimulationResultsError')
+        err.message = 'Simulation did not produce expected effects'
+        err.reason = invalidEthReceiveValue
+          ? 'invalid ETH balance.value in balanceChanges: willReceive'
+          : 'missing positive ETH in balanceChanges: willReceive (expected pending refund)'
+        err.hint = 'undelegate-eth-simulation-results-error'
+        throw err
+      } else {
+        console.warn(
+          'Simulation for ETH undelegate returned issues',
+          simulationResponse?.metadata?.humanReadableError
+        )
+      }
+    }
+  }
+}

package/src/staking/fantom-staking.js

@@ -7,7 +7,7 @@ export class FantomStaking {
     this.sfcContract = createContract(SFC_ADDRESS, 'fantomSfc')
   }
 
-  buildTxData = (contract, method, ...args) => {
+  #buildTxData = (contract, method, ...args) => {
     return contract[method].build(...args)
   }
 
@@ -16,7 +16,7 @@ export class FantomStaking {
    */
   delegate = ({ validatorId }) => {
     this.#validateValidatorId(validatorId)
-    return this.buildTxData(this.sfcContract, 'delegate', validatorId)
+    return this.#buildTxData(this.sfcContract, 'delegate', validatorId)
   }
 
   /**
@@ -31,7 +31,7 @@ export class FantomStaking {
   undelegate = ({ requestId, validatorId, amount }) => {
     this.#validateRequestId(requestId)
     this.#validateValidatorId(validatorId)
-    return this.buildTxData(this.sfcContract, 'undelegate', validatorId, requestId, amount)
+    return this.#buildTxData(this.sfcContract, 'undelegate', validatorId, requestId, amount)
   }
 
   /**
@@ -44,7 +44,7 @@ export class FantomStaking {
   withdraw = ({ requestId, validatorId }) => {
     this.#validateRequestId(requestId)
     this.#validateValidatorId(validatorId)
-    return this.buildTxData(this.sfcContract, 'withdraw', validatorId, requestId)
+    return this.#buildTxData(this.sfcContract, 'withdraw', validatorId, requestId)
   }
 
   /**
@@ -53,7 +53,7 @@ export class FantomStaking {
    */
   claimRewards = ({ validatorId }) => {
     this.#validateValidatorId(validatorId)
-    return this.buildTxData(this.sfcContract, 'claimRewards', validatorId)
+    return this.#buildTxData(this.sfcContract, 'claimRewards', validatorId)
   }
 
   /**
@@ -62,7 +62,7 @@ export class FantomStaking {
    */
   restakeRewards = ({ validatorId }) => {
     this.#validateValidatorId(validatorId)
-    return this.buildTxData(this.sfcContract, 'restakeRewards', validatorId)
+    return this.#buildTxData(this.sfcContract, 'restakeRewards', validatorId)
   }
 
   /**
@@ -71,7 +71,7 @@ export class FantomStaking {
   lockStake = ({ validatorId, amount, durationSeconds }) => {
     this.#validateValidatorId(validatorId)
     this.#validateDuration(durationSeconds)
-    return this.buildTxData(this.sfcContract, 'lockStake', validatorId, durationSeconds, amount)
+    return this.#buildTxData(this.sfcContract, 'lockStake', validatorId, durationSeconds, amount)
   }
 
   /**
@@ -80,7 +80,7 @@ export class FantomStaking {
   relockStake = ({ validatorId, amount, durationSeconds }) => {
     this.#validateValidatorId(validatorId)
     this.#validateDuration(durationSeconds)
-    return this.buildTxData(this.sfcContract, 'relockStake', validatorId, durationSeconds, amount)
+    return this.#buildTxData(this.sfcContract, 'relockStake', validatorId, durationSeconds, amount)
   }
 
   /**
@@ -88,7 +88,7 @@ export class FantomStaking {
    */
   unlockStake = ({ validatorId, amount }) => {
     this.#validateValidatorId(validatorId)
-    return this.buildTxData(this.sfcContract, 'unlockStake', validatorId, amount)
+    return this.#buildTxData(this.sfcContract, 'unlockStake', validatorId, amount)
   }
 
   #validateValidatorId = (validatorId) => {

package/src/staking/index.js

@@ -1,4 +1,4 @@
-export { FantomStaking } from './fantom-staking'
-export { stakingProviderClientFactory } from './staking-provider-client'
-export * from './ethereum'
-export * from './matic'
+export { FantomStaking } from './fantom-staking.js'
+export { stakingProviderClientFactory } from './staking-provider-client.js'
+export * from './ethereum/index.js'
+export * from './matic/index.js'

package/src/staking/matic/addresses.js

@@ -0,0 +1,2 @@
+export const EVERSTAKE_VALIDATOR_CONTRACT_ADDR = '0xf30cf4ed712d3734161fdaab5b1dbb49fd2d0e5c'
+export const STAKING_MANAGER_ADDR = '0x5e3ef299fddf15eaa0432e6e66473ace8c13d908'

package/src/staking/matic/api.js

@@ -1,23 +1,29 @@
-import BN from 'bn.js'
 import { createContract } from '@exodus/ethereum-lib'
 import ethAssets from '@exodus/ethereum-meta'
+import { bufferToHex } from '@exodus/ethereumjs/util'
+import { safeString } from '@exodus/safe-string'
 import { retry } from '@exodus/simple-retry'
-import { bufferToHex } from '@exodus/ethereumjs-util'
+import BN from 'bn.js'
 import assert from 'minimalistic-assert'
 
+import { EVM_ERROR_REASONS, withErrorReason } from '../../error-wrapper.js'
+import { fromHexToBN, fromHexToString, splitIn32BytesArray } from '../../number-utils.js'
+import { EVERSTAKE_VALIDATOR_CONTRACT_ADDR, STAKING_MANAGER_ADDR } from './addresses.js'
+
+const EVERSTAKE_API_URL = 'https://polygon-clarity.a.exodus.io/everstake-rewards'
+
 const polygonEthToken = ethAssets.find(({ name: tokenName }) => tokenName === 'polygon')
 
 const RETRY_DELAYS = ['10s']
 export class MaticStakingApi {
-  static EVERSTAKE_VALIDATOR_CONTRACT_ADDR = '0xf30cf4ed712d3734161fdaab5b1dbb49fd2d0e5c'
-  static STAKING_MANAGER_ADDR = '0x5e3ef299fddf15eaa0432e6e66473ace8c13d908'
+  static EVERSTAKE_VALIDATOR_CONTRACT_ADDR = EVERSTAKE_VALIDATOR_CONTRACT_ADDR
+  static STAKING_MANAGER_ADDR = STAKING_MANAGER_ADDR
 
-  constructor({
+  constructor(
     validatorId = MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
     stakeManagerAddr = MaticStakingApi.STAKING_MANAGER_ADDR,
-    server,
-  }) {
-    assert(server, 'server is required')
+    server
+  ) {
     // harcoded exchange rate from the validtor share contract
     // in order to calculate claim unstake amount off-chain
     this.EXCHANGE_RATE_PRECISION = new BN(10).pow(new BN(29))
@@ -27,12 +33,12 @@ export class MaticStakingApi {
     this.server = server
   }
 
-  buildTxData = (contract, method, ...args) => {
+  #buildTxData = (contract, method, ...args) => {
     return contract[method].build(...args)
   }
 
-  callReadFunctionContract = (contract, method, ...args) => {
-    const callData = this.buildTxData(contract, method, ...args)
+  #callReadFunctionContract = (contract, method, ...args) => {
+    const callData = this.#buildTxData(contract, method, ...args)
     const data = {
       data: bufferToHex(callData),
       to: contract.address,
@@ -40,19 +46,25 @@ export class MaticStakingApi {
     }
 
     const eth = this.server
-    return retry(eth.ethCall, { delayTimesMs: RETRY_DELAYS })(data)
+    assert(eth, 'server is required')
+    return withErrorReason({
+      promise: retry((...args) => eth.ethCall(...args), { delayTimesMs: RETRY_DELAYS })(data),
+      errorReasonInfo: EVM_ERROR_REASONS.ethCallFailed,
+      hint: safeString`stakingMaticReadFunctionContract`,
+      baseAssetName: eth.baseAssetName,
+    })
   }
 
   getWithdrawalDelay = async () => {
-    const withdrawalDelay = await this.callReadFunctionContract(
+    const withdrawalDelay = await this.#callReadFunctionContract(
       this.stakingManagerContract,
       'withdrawalDelay'
     )
-    return toBN(withdrawalDelay)
+    return fromHexToBN(withdrawalDelay)
   }
 
   getMinRewardsToWithdraw = async () => {
-    const minRewardsToWithdraw = await this.callReadFunctionContract(
+    const minRewardsToWithdraw = await this.#callReadFunctionContract(
       this.validatorShareContract,
       'minAmount'
     )
@@ -64,8 +76,8 @@ export class MaticStakingApi {
    * 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)
+    const currentEpoch = await this.#callReadFunctionContract(this.stakingManagerContract, 'epoch')
+    return fromHexToBN(currentEpoch)
   }
 
   /**
@@ -79,7 +91,7 @@ export class MaticStakingApi {
       _nonce = await this.getCurrentUnbondNonce(address)
     }
 
-    const unboundInfo = await this.callReadFunctionContract(
+    const unboundInfo = await this.#callReadFunctionContract(
       this.validatorShareContract,
       'unbonds_new',
       address,
@@ -88,18 +100,18 @@ export class MaticStakingApi {
 
     const [shares, withdrawEpoch] = splitIn32BytesArray(unboundInfo)
     return {
-      withdrawEpoch: toBN(withdrawEpoch),
-      shares: toBN(shares),
+      withdrawEpoch: fromHexToBN(withdrawEpoch),
+      shares: fromHexToBN(shares),
     }
   }
 
   /**
    * UnbondNonce is a counter stored in the contract that tracks each time a delegator unstakes
    * @param address delegator address
-   * @return current unbonded nonce
+   * @returns current unbonded nonce
    */
   getCurrentUnbondNonce = async (address) => {
-    const unbondNonce = await this.callReadFunctionContract(
+    const unbondNonce = await this.#callReadFunctionContract(
       this.validatorShareContract,
       'unbondNonces',
       address
@@ -108,7 +120,8 @@ export class MaticStakingApi {
   }
 
   getLiquidRewards = async (address) => {
-    const liquidRewards = await this.callReadFunctionContract(
+    // latest accrued rewards
+    const liquidRewards = await this.#callReadFunctionContract(
       this.validatorShareContract,
       'getLiquidRewards',
       address
@@ -116,23 +129,46 @@ export class MaticStakingApi {
     return polygonEthToken.currency.baseUnit(liquidRewards)
   }
 
+  getTotalRewards = async (address) => {
+    // use external everstake API to get total rewards
+    const url = new URL(EVERSTAKE_API_URL)
+
+    const options = {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        address,
+      }),
+    }
+
+    try {
+      const response = await fetch(url.toString(), options)
+      const res = await response.json()
+      if (res === 'address' || !res?.rewards) return polygonEthToken.currency.ZERO // address not found
+      return polygonEthToken.currency.baseUnit(res.rewards)
+    } catch (error) {
+      console.warn('Error fetching Polygon total rewards:', error)
+      return polygonEthToken.currency.ZERO
+    }
+  }
+
   getTotalStake = async (address) => {
-    const stakeInfo = await this.callReadFunctionContract(
+    const stakeInfo = await this.#callReadFunctionContract(
       this.validatorShareContract,
       'getTotalStake',
       address
     )
     const [amount] = splitIn32BytesArray(stakeInfo)
-    return polygonEthToken.currency.baseUnit(toBN(amount).toString())
+    return polygonEthToken.currency.baseUnit(fromHexToString(amount))
   }
 
   getWithdrawExchangeRate = async () => {
-    const withdrawExchangeRate = await this.callReadFunctionContract(
+    const withdrawExchangeRate = await this.#callReadFunctionContract(
       this.validatorShareContract,
       'withdrawExchangeRate'
     )
 
-    return toBN(withdrawExchangeRate)
+    return fromHexToBN(withdrawExchangeRate)
   }
 
   /**
@@ -145,7 +181,7 @@ export class MaticStakingApi {
    * @param amount Matic tokens to be approved for StakeManager to withdraw (polygon currency)
    */
   approveStakeManager = (amount) => {
-    return this.buildTxData(
+    return this.#buildTxData(
       this.polygonContract,
       'increaseAllowance',
       this.stakingManagerContract.address,
@@ -154,20 +190,20 @@ export class MaticStakingApi {
   }
 
   restakeReward = () => {
-    return this.buildTxData(this.validatorShareContract, 'restake')
+    return this.#buildTxData(this.validatorShareContract, 'restake')
   }
 
   withdrawRewards = () => {
-    return this.buildTxData(this.validatorShareContract, 'withdrawRewards')
+    return this.#buildTxData(this.validatorShareContract, 'withdrawRewards')
   }
 
   delegate = ({ amount }) => {
-    return this.buildTxData(this.validatorShareContract, 'buyVoucher', amount.toBaseString(), '0')
+    return this.#buildTxData(this.validatorShareContract, 'buyVoucher', amount.toBaseString(), '0')
   }
 
   undelegate = ({ amount, maximumSharesToBurn }) => {
     const _maximumSharesToBurn = maximumSharesToBurn || amount
-    return this.buildTxData(
+    return this.#buildTxData(
       this.validatorShareContract,
       'sellVoucher_new',
       amount.toBaseString(),
@@ -179,22 +215,6 @@ export class MaticStakingApi {
    * @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 this.#buildTxData(this.validatorShareContract, 'unstakeClaimTokens_new', unbondNonce)
   }
-
-  return str.startsWith('0x') ? str.slice(2) : str
 }

package/src/staking/matic/index.js

@@ -1,9 +1,9 @@
-export { MaticStakingApi } from './api'
-export { createPolygonStakingService, getPolygonStakingInfo } from './service'
+export { MaticStakingApi } from './api.js'
 export {
   isPolygonTx,
   isPolygonDelegate,
   isPolygonUndelegate,
   isPolygonReward,
   isPolygonClaimUndelegate,
-} from './matic-staking-utils'
+  isPendingPolygonUndelegateTxInEthereumTxLog,
+} from './matic-staking-utils.js'