@exodus/ethereum-api 9.0.0-alpha.3 → 9.0.1

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

@@ -1,7 +1,15 @@
-import { MaticStakingApi } from './api'
+import NumberUnit from '@exodus/currency'
+import { getMethodIdFromEthTx, isPendingTxInLog, parseUnsignedTx } from '@exodus/ethereum-lib'
+import assetsList, { asset as ethereum } from '@exodus/ethereum-meta'
+import { Tx } from '@exodus/models'
+import assert from 'minimalistic-assert'
+
+import { simulateTransactions as simulateEthereumTransactions } from '../../simulation/simulate-transactions.js'
+import { decodePolygonStakingTxInputAmount } from '../../tx-log-staking-processor/utils.js'
+import { MaticStakingApi } from './api.js'
 
 // function selector for buyVoucher(uint256 _amount, uint256 _minSharesToMint)
-const DELEGATE = '0x6ab15071'
+export const DELEGATE = '0x6ab15071'
 // function selector for sellVoucher_new(uint256 claimAmount, uint256 maximumSharesToBurn)
 const UNDELEGATE = '0xc83ec04d'
 // function selector for withdrawRewards()
@@ -11,14 +19,244 @@ const CLAIM_UNDELEGATE_BALANCE = '0xe97fddc2'
 
 const STAKING_MANAGER_CONTRACT = MaticStakingApi.STAKING_MANAGER_ADDR
 
+const METHOD_ID_CHAR_LENGTH = 10
+
+const { currency: polygonCurrency } = assetsList.find(
+  ({ name: tokenName }) => tokenName === 'polygon'
+)
+const currencies = { ethereum: ethereum.currency, polygon: polygonCurrency }
+
 export const isPolygonTx = ({ coinName }) => coinName === 'polygon'
 export const isPolygonDelegate = (tx) =>
   isPolygonTx(tx) && tx.to === STAKING_MANAGER_CONTRACT && tx.data?.methodId === DELEGATE
 export const isPolygonUndelegate = (tx) =>
-  isPolygonTx(tx) && tx.from[0] === STAKING_MANAGER_CONTRACT && tx.data?.methodId === UNDELEGATE
+  isPolygonTx(tx) && tx.from?.[0] === STAKING_MANAGER_CONTRACT && tx.data?.methodId === UNDELEGATE
 export const isPolygonReward = (tx) =>
-  isPolygonTx(tx) && tx.from[0] === STAKING_MANAGER_CONTRACT && tx.data?.methodId === CLAIM_REWARD
+  isPolygonTx(tx) && tx.from?.[0] === STAKING_MANAGER_CONTRACT && tx.data?.methodId === CLAIM_REWARD
 export const isPolygonClaimUndelegate = (tx) =>
   isPolygonTx(tx) &&
-  tx.from[0] === STAKING_MANAGER_CONTRACT &&
+  tx.from?.[0] === STAKING_MANAGER_CONTRACT &&
   tx.data?.methodId === CLAIM_UNDELEGATE_BALANCE
+
+const isPolygonStakingContractTxInEthereumTxLog = (tx) =>
+  tx.to === MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR
+
+const isPolygonStakingContractCallInEthTx = ({ tx, methodId }) =>
+  tx?.data?.data?.slice?.(0, Math.max(0, METHOD_ID_CHAR_LENGTH)) === methodId // ETH txs have contract data in 'data'
+
+const isPolygonUndelegateTxInEthreumTxLog = (tx) =>
+  isPolygonStakingContractCallInEthTx({ tx, methodId: UNDELEGATE })
+
+// Some polygon unstake txs are only kept in the ETH tx log rather than Polygon tx log.
+// This is b/c the given tx does not have any ERC2O token transfer (MATIC).
+// Token tx log only has txs which contains ERC2O token transfer of the given token.
+export const isPolygonUndelegateTxInEthereumTxLog = (tx) =>
+  isPolygonStakingContractTxInEthereumTxLog(tx) && isPolygonUndelegateTxInEthreumTxLog(tx)
+
+// Pending variant intended for client-side selectors (e.g. "show Unstaking… as
+// soon as the tx hits the log"). Composes the shared tx-log lifecycle and
+// method-ID helpers so this and the asset-side preflight in
+// @exodus/ethereum-plugin/staking/polygon/staking-utils agree on what "pending"
+// means from a single definition.
+export const isPendingPolygonUndelegateTxInEthereumTxLog = (tx) =>
+  !!tx &&
+  isPendingTxInLog(tx) &&
+  tx.to?.toLowerCase() === MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR &&
+  getMethodIdFromEthTx(tx, UNDELEGATE) === UNDELEGATE
+
+export const createUndelegateTx = (tx) => {
+  return Tx.fromJSON({
+    ...tx,
+    coinName: 'polygon',
+    coinAmount: currencies.polygon.ZERO,
+    tokens: [],
+    currencies,
+    from: [STAKING_MANAGER_CONTRACT],
+  })
+}
+
+export const getPolygonUndelegateTxInEthereumTxLog = (ethereumLogItems) => {
+  if (!ethereumLogItems || ethereumLogItems.length === 0) return []
+
+  const polygonLogItems = []
+  const polygonEthUndelegateTxs = [...ethereumLogItems].filter((tx) =>
+    isPolygonUndelegateTxInEthereumTxLog(tx)
+  )
+  const polygonUndelegateTxs = [...polygonEthUndelegateTxs].map((tx) => createUndelegateTx(tx))
+
+  for (const polygonTx of polygonUndelegateTxs) {
+    polygonLogItems.push(polygonTx)
+  }
+
+  polygonLogItems.sort((a, b) => new Date(b.date) - new Date(a.date))
+
+  return polygonLogItems
+}
+
+// Build simulation transaction requests from unsigned transactions
+export function createMaticStakeSimRequestsFromUnsigned({
+  asset,
+  unsignedTxApprove,
+  unsignedTxDelegate,
+}) {
+  const build = (tx) => {
+    const parsed = parseUnsignedTx({ asset, unsignedTx: tx.unsignedTx })
+    const gasPriceUnit = tx.gasPrice
+    const chainId = tx.unsignedTx?.txData?.chainId
+    const from = tx.unsignedTx?.txMeta?.fromAddress
+    const to = tx.unsignedTx?.txMeta?.toAddress
+
+    assert(gasPriceUnit 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(gasPriceUnit.toBaseString()).toString(16)}`,
+      value: '0x0',
+      data: `0x${parsed.data?.toString('hex')}`,
+      nonce: `0x${parsed.nonce.toString(16)}`,
+    }
+  }
+
+  return {
+    approveTxRequest: build(unsignedTxApprove),
+    delegateTxRequest: build(unsignedTxDelegate),
+  }
+}
+
+export async function maticDelegateOptimisticSideEffectTxLogs({
+  asset, // Base asset
+  walletAccount,
+  feeAmount,
+  delegateTxId,
+  nonce,
+  estimatedDelegateGasLimit,
+  tipGasPrice,
+  transactionData,
+  date,
+  bundleId,
+}) {
+  // Decode the amount from the delegate transaction data
+  // transactionData is already parsed from unsignedTx using parseUnsignedTx
+  let amount
+  try {
+    // Decode the contract call data - buyVoucher(uint256 _amount, uint256 _minSharesToMint)
+    const decodedAmount = decodePolygonStakingTxInputAmount({ data: { data: transactionData } })
+    // Convert to NumberUnit - the decoded amount is a string like '100000000'
+    amount = polygonCurrency.baseUnit(decodedAmount)
+  } catch (e) {
+    console.error(
+      'Could not decode MATIC delegate transaction data:',
+      delegateTxId,
+      e.message,
+      transactionData
+    )
+    return [] // Could not decode the amount
+  }
+
+  const tokenAssetName = 'polygon'
+  return [
+    {
+      assetName: tokenAssetName,
+      walletAccount,
+      txs: [
+        {
+          confirmations: 0,
+          feeAmount,
+          feeCoinName: asset.feeAsset.name,
+          selfSend: false,
+          to: MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR,
+          txId: delegateTxId,
+          data: {
+            gasLimit: estimatedDelegateGasLimit,
+            nonce,
+            tipGasPrice: tipGasPrice ? tipGasPrice.toBaseString() : undefined,
+            methodId: DELEGATE,
+            ...(bundleId ? { bundleId } : null),
+          },
+          coinAmount: amount.abs().negate(),
+          coinName: tokenAssetName,
+          currencies: {
+            [tokenAssetName]: polygonCurrency,
+            [asset.feeAsset.name]: asset.feeAsset.currency,
+          },
+          date,
+        },
+      ],
+    },
+  ]
+}
+
+export async function maticDelegateSimulateTransactions({
+  asset,
+  unsignedTxApprove,
+  unsignedTxDelegate,
+  senderAddress,
+  revertOnSimulationError,
+}) {
+  const { approveTxRequest, delegateTxRequest } = createMaticStakeSimRequestsFromUnsigned({
+    asset: asset.baseAsset,
+    unsignedTxApprove,
+    unsignedTxDelegate,
+  })
+
+  // Simulate transactions
+  const simulationTxData = {
+    baseAssetName: asset.baseAsset.name,
+    origin: 'exodus-staking',
+    senderAddress,
+  }
+
+  const simulationResponse = await simulateEthereumTransactions({
+    asset: asset.baseAsset,
+    ...simulationTxData,
+    transactions: [approveTxRequest, delegateTxRequest],
+  })
+  // These checks are only for simulation issues, not validation of the transactions
+  if (simulationResponse?.warnings?.length || simulationResponse?.metadata?.humanReadableError) {
+    if (revertOnSimulationError) {
+      const err = new Error('StakingMaticSimulationError')
+      err.message = simulationResponse?.metadata?.humanReadableError
+      err.reason = `warnings: ${simulationResponse.warnings.join(', ')}`
+      err.hint = 'delegate-matic-simulation-error'
+      throw err
+    } else {
+      console.warn(
+        'Simulation for staking matic returned issues',
+        simulationResponse?.metadata?.humanReadableError
+      )
+    }
+  }
+
+  // For validation of the transactions, we need to check if the simulation produced the expected effects
+  // hasApprove, hasSend, hasReceive entries must be present
+  const { balanceChanges = Object.create(null) } = simulationResponse || Object.create(null)
+  const asArray = (v) => (Array.isArray(v) ? v : [])
+  const hasApprove = asArray(balanceChanges.willApprove).length > 0
+  const hasSend = asArray(balanceChanges.willSend).length > 0
+  const hasReceive = asArray(balanceChanges.willReceive).length > 0
+
+  if (!(hasApprove && hasSend && hasReceive)) {
+    if (revertOnSimulationError) {
+      const missing = []
+      if (!hasApprove) missing.push('willApprove')
+      if (!hasSend) missing.push('willSend')
+      if (!hasReceive) missing.push('willReceive')
+      const err = new Error('StakingMaticSimulationResultsError')
+      err.message = 'Simulation did not produce expected effects'
+      err.reason = `missing balanceChanges: ${missing.join(', ')}`
+      err.hint = 'delegate-matic-simulation-results-error'
+      throw err
+    } else {
+      console.warn(
+        'Simulation for staking matic returned issues',
+        simulationResponse?.metadata?.humanReadableError
+      )
+    }
+  }
+}

package/src/staking/matic/matic-staking.md

@@ -13,6 +13,59 @@ Stakers are divided into `validators`, `delegators`, and watchers (for fraud rep
 
 `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).
 
+#### Storage Layout
+
+```
+| Name                        | Type                                                       | Slot | Offset | Bytes | Value                                            | Hex Value                                                          | Contract                                                     |
+|-----------------------------|------------------------------------------------------------|------|--------|-------|--------------------------------------------------|--------------------------------------------------------------------|--------------------------------------------------------------|
+| locked                      | bool                                                       | 0    | 0      | 1     | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| governance                  | contract IGovernance                                       | 0    | 1      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| _owner                      | address                                                    | 1    | 0      | 20    | 289681683732047618769883796824487869827960101094 | 0x00000000000000000000000032bdc6a4e8c654df65503cbb0edc82b4ce9158e6 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| rootChain                   | address                                                    | 2    | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| token                       | contract IERC20                                            | 3    | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| registry                    | address                                                    | 4    | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| logger                      | contract StakingInfo                                       | 5    | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| NFTContract                 | contract StakingNFT                                        | 6    | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| validatorShareFactory       | contract ValidatorShareFactory                             | 7    | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| WITHDRAWAL_DELAY            | uint256                                                    | 8    | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| currentEpoch                | uint256                                                    | 9    | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| dynasty                     | uint256                                                    | 10   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| CHECKPOINT_REWARD           | uint256                                                    | 11   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| minDeposit                  | uint256                                                    | 12   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| minHeimdallFee              | uint256                                                    | 13   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| checkPointBlockInterval     | uint256                                                    | 14   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| signerUpdateLimit           | uint256                                                    | 15   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| validatorThreshold          | uint256                                                    | 16   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| totalStaked                 | uint256                                                    | 17   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| NFTCounter                  | uint256                                                    | 18   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| totalRewards                | uint256                                                    | 19   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| totalRewardsLiquidated      | uint256                                                    | 20   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| auctionPeriod               | uint256                                                    | 21   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| proposerBonus               | uint256                                                    | 22   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| accountStateRoot            | bytes32                                                    | 23   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| replacementCoolDown         | uint256                                                    | 24   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| delegationEnabled           | bool                                                       | 25   | 0      | 1     | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| validators                  | mapping(uint256 => struct StakeManagerStorage.Validator)   | 26   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| signerToValidator           | mapping(address => uint256)                                | 27   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| validatorState              | struct StakeManagerStorage.State                           | 28   | 0      | 64    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| validatorStateChanges       | mapping(uint256 => struct StakeManagerStorage.StateChange) | 30   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| userFeeExit                 | mapping(address => uint256)                                | 31   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| validatorAuction            | mapping(uint256 => struct StakeManagerStorage.Auction)     | 32   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| latestSignerUpdateEpoch     | mapping(uint256 => uint256)                                | 33   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| totalHeimdallFee            | uint256                                                    | 34   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| inited                      | bool                                                       | 35   | 0      | 1     | 1                                                | 0x0000000000000000000000000000000000000000000000000000000000000001 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| eventsHub                   | address                                                    | 35   | 1      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| rewardPerStake              | uint256                                                    | 36   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| extensionCode               | address                                                    | 37   | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| signers                     | address[]                                                  | 38   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| prevBlockInterval           | uint256                                                    | 39   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| rewardDecreasePerCheckpoint | uint256                                                    | 40   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| maxRewardedCheckpoints      | uint256                                                    | 41   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| checkpointRewardDelta       | uint256                                                    | 42   | 0      | 32    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| tokenMatic                  | contract IERC20                                            | 43   | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+| migration                   | contract IPolygonMigration                                 | 44   | 0      | 20    | 0                                                | 0x0000000000000000000000000000000000000000000000000000000000000000 | contracts/staking/stakeManager/StakeManager.sol:StakeManager |
+```
+
 ### 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

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

@@ -1,5 +1,5 @@
-import assert from 'minimalistic-assert'
 import fetchival from '@exodus/fetch/experimental/fetchival'
+import assert from 'minimalistic-assert'
 import ms from 'ms'
 
 const DEFAULT_STAKING_URL = 'https://staking.a.exodus.io'

package/src/staking/utils/index.js

@@ -0,0 +1,39 @@
+import { isNumberUnit } from '@exodus/currency'
+
+export const DISABLE_BALANCE_CHECKS = '0x0'
+
+export function amountToCurrency({ asset, amount }) {
+  return isNumberUnit(amount) ? amount : asset.currency.parse(amount)
+}
+
+/**
+ * Previously, EVM staking services would determine `feeData`
+ * dynamically on behalf of callers, however, this risks invalidating
+ * fee estimation over the course of a sequence of multiple staking
+ * transactions.
+ *
+ * For example, when determining the amount for a `sendAll`
+ * transaction, if the gas price were to increase between estimation
+ * and execution, this would invalidate the previous estimation.
+ *
+ * In future usage, we would want assets code to fetch FeeData from ACI,
+ * construct a transaction including determining the fee and then report
+ * back to the client what the fee is going to be.
+ *
+ * Importantly, the provided `feeData` must be sufficiently
+ * up-to-date; else, we risk the transactions not being included at all.
+ */
+export const resolveFeeData = async ({
+  // TODO: maybe asset name would be better
+  asset,
+  assetClientInterface,
+  feeData,
+}) => {
+  if (feeData) return feeData
+
+  console.warn(
+    'The evm staking service was not explicitly passed `feeData`. This can result in transaction nondeterminism.'
+  )
+
+  return assetClientInterface.getFeeData({ assetName: asset.name })
+}