@exodus/ethereum-api 8.59.2 → 8.60.0

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [8.60.0](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.59.2...@exodus/ethereum-api@8.60.0) (2025-11-22)
+
+
+### Features
+
+
+* feat: Bundle approve and delegate functions for Matic staking (With simulation) (#6707)
+
+* feat: Default privacyRpcUrl (SERVO) (#6968)
+
+
+
 ## [8.59.2](https://github.com/ExodusMovement/assets/compare/@exodus/ethereum-api@8.59.1...@exodus/ethereum-api@8.59.2) (2025-11-19)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/ethereum-api",
-  "version": "8.59.2",
+  "version": "8.60.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Ethereum and EVM-based blockchains",
   "type": "module",
   "main": "src/index.js",
@@ -67,5 +67,5 @@
     "type": "git",
     "url": "git+https://github.com/ExodusMovement/assets.git"
   },
-  "gitHead": "d1505076f4e06aad8f7962d9fad12354c020a30c"
+  "gitHead": "93a853e1bd1595de3e72f7ba3ceb5826d018c71a"
 }

package/src/create-asset-utils.js

@@ -61,7 +61,7 @@ export const resolveMonitorSettings = (
   return { ...defaultResolution, monitorType: overrideMonitorType, serverUrl: overrideServerUrl }
 }
 
-const stringifyPrivateTx = (tx) => {
+export const stringifyPrivateTx = (tx) => {
   assert(tx, 'expected tx')
   if (tx instanceof Uint8Array) return `0x${Buffer.from(tx).toString('hex')}`
 
@@ -75,14 +75,21 @@ const broadcastPrivateBundleFactory =
   ({ privacyServer }) =>
   async ({ txs }) => {
     assert(Array.isArray(txs), 'txs must be an array')
-    if (txs.length === 0) return
+    assert(txs.length > 0, 'txs must be an non-empty array')
 
-    await privacyServer.sendRequest(
+    const sendBundleResult = await privacyServer.sendRequest(
       privacyServer.buildRequest({
         method: 'eth_sendBundle',
         params: [{ txs: txs.map((tx) => stringifyPrivateTx(tx)) }],
       })
     )
+    if (typeof sendBundleResult === 'string') return { bundleHash: sendBundleResult }
+
+    const bundleHash = sendBundleResult?.bundleHash
+    if (typeof bundleHash === 'string') return { bundleHash }
+
+    console.warn('unexpected sendBundleResult shape, cannot determine bundle hash')
+    return null
   }
 
 export const createTransactionPrivacyFactory = ({ assetName, privacyRpcUrl }) => {

package/src/create-asset.js

@@ -69,6 +69,7 @@ export const createAssetFactory = ({
   supportsCustomFees: defaultSupportsCustomFees = false,
   useAbsoluteBalanceAndNonce = false,
   delisted = false,
+  privacyRpcUrl: defaultPrivacyRpcUrl,
 }) => {
   assert(assetsList, 'assetsList is required')
   assert(providedFeeData || feeDataConfig, 'feeData or feeDataConfig is required')
@@ -91,6 +92,7 @@ export const createAssetFactory = ({
     supportsCustomFees: defaultSupportsCustomFees,
     nfts: defaultNfts,
     customTokens: defaultCustomTokens,
+    privacyRpcUrl: defaultPrivacyRpcUrl,
   }
   return (
     {

package/src/staking/ethereum/service.js

@@ -60,7 +60,7 @@ export function createEthereumStakingService({
     return { delegatorAddress, feeData }
   }
 
-  async function delegate({ walletAccount, amount, feeData, isDelegateAll } = Object.create(null)) {
+  async function delegate({ walletAccount, amount, feeData, isDelegateAll }) {
     const asset = await getAsset(assetName)
     const staking = getStakingApi(asset)
     amount = amountToCurrency({ asset, amount })
@@ -230,9 +230,7 @@ export function createEthereumStakingService({
     return undelegatePendingFee.add(undelegateFee)
   }
 
-  async function undelegate(
-    { walletAccount, amount, feeData, waitForConfirmation = true } = Object.create(null)
-  ) {
+  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = true }) {
     const asset = await getAsset(assetName)
     const staking = getStakingApi(asset)
     const minAmount = getMinAmount(asset)
@@ -312,7 +310,7 @@ export function createEthereumStakingService({
     return txId
   }
 
-  async function claimUndelegatedBalance({ walletAccount, feeData } = Object.create(null)) {
+  async function claimUndelegatedBalance({ walletAccount, feeData }) {
     const asset = await getAsset(assetName)
     const staking = getStakingApi(asset)
 
@@ -495,20 +493,18 @@ export function createEthereumStakingService({
     }
   }
 
-  async function prepareAndSendTx(
-    {
-      asset,
-      walletAccount,
-      to,
-      amount,
-      txData: txInput,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      waitForConfirmation = false,
-      feeData,
-    } = Object.create(null)
-  ) {
+  async function prepareAndSendTx({
+    asset,
+    walletAccount,
+    to,
+    amount,
+    txData: txInput,
+    gasPrice,
+    gasLimit,
+    tipGasPrice,
+    waitForConfirmation = false,
+    feeData,
+  }) {
     const sendTxArgs = {
       asset,
       walletAccount,

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

@@ -1,10 +1,14 @@
+import NumberUnit from '@exodus/currency'
+import { 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 { 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()
@@ -76,3 +80,170 @@ export const getPolygonUndelegateTxInEthereumTxLog = (ethereumLogItems) => {
 
   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 asset.baseAsset.api.web3.simulateTransactions({
+    ...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/service.js

@@ -2,6 +2,7 @@ import { memoize } from '@exodus/basic-utils'
 
 import { estimateGasLimit, scaleGasLimitEstimate } from '../../gas-estimation.js'
 import { getAggregateTransactionPricing } from '../../get-fee.js'
+import { getOptimisticTxLogEffects } from '../../tx-log/get-optimistic-txlog-effects.js'
 import { createWatchTx as defaultCreateWatch } from '../../watch-tx.js'
 import { stakingProviderClientFactory } from '../staking-provider-client.js'
 import {
@@ -10,6 +11,7 @@ import {
   resolveFeeData as defaultResolveFeeData,
 } from '../utils/index.js'
 import { MaticStakingApi } from './api.js'
+import { maticDelegateSimulateTransactions } from './matic-staking-utils.js'
 
 const createStakingApiForFeeAsset = ({ feeAsset: { server } }) =>
   new MaticStakingApi(undefined, undefined, server)
@@ -68,86 +70,146 @@ export function createPolygonStakingService({
     return address.toLowerCase()
   }
 
-  async function delegate({ walletAccount, amount, feeData, waitForConfirmation = false } = {}) {
-    const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
+  /**
+   * Delegate MATIC tokens for staking.
+   * @param {walletAccount} params.walletAccount - The walletAccount for the delegator (required).
+   * @param {NumberUnit} params.amount - The amount of MATIC to delegate (required).
+   * @param {FeeData} params.feeData - Optional feeData to use for the transaction (optional, if not provided will be obtained from the asset client interface).
+   * @param {Boolean} params.revertOnSimulationError - Optional boolean to revert on simulation error (optional, default is true). Allows us to quickly react to simulator issues.
+   */
+  async function delegate({ walletAccount, amount, feeData, revertOnSimulationError = true }) {
+    const [delegatorAddress, { asset, stakingApi }, resolvedFeeData] = await Promise.all([
       getDelegatorAddress({ walletAccount }),
       createStakingApi(),
+      resolveFeeData({ feeData }),
     ])
 
-    // NOTE: We do not provide a silent fallback for `feeData` omission
-    //       for a delegation transaction, since `feeData` is expected
-    //       to have been provided during `estimateDelegateTxFee`.
-    feeData = await resolveFeeData({ feeData })
+    feeData = resolvedFeeData
 
-    amount = amountToCurrency({ asset, amount })
+    const baseNonce = await asset.baseAsset.getNonce({
+      asset,
+      fromAddress: delegatorAddress.toString(),
+      walletAccount,
+    })
+
+    const [txApproveData, txDelegateData] = await Promise.all([
+      stakingApi.approveStakeManager(amount),
+      stakingApi.delegate({ amount }),
+    ])
 
-    const txApproveData = await stakingApi.approveStakeManager(amount)
-    let { gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
+    const {
+      gasPrice,
+      gasLimit: approveGasLimit,
+      tipGasPrice,
+    } = await estimateTxFee({
       from: delegatorAddress,
       to: stakingApi.polygonContract.address,
       txInput: txApproveData,
       feeData,
     })
-    await prepareAndSendTx({
-      walletAccount,
-      waitForConfirmation,
-      to: stakingApi.polygonContract.address,
-      txData: txApproveData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
+
+    // Estimate based on the average gas usage for the delegate transaction. 250000 is the average.
+    const { gasLimit: estimatedDelegateGasLimit } = await estimateDelegateTxFee({
       feeData,
     })
 
-    // NOTE: Whenever we `waitForConfirmation`, we must recalculate
-    //       the `feeData` as this may have changed since our last
-    //       transaction was mined.
-    //
-    //       In most cases, this shouldn't affect previous estimates,
-    //       since the amount we aren't trying to stake using the
-    //       base currency; however for users with marginal balances,
-    //       an increase in `gasPrice` could result in transaction
-    //       failure.
-    //
-    // HACK: This will invaldiate the original estimate in calculated
-    //       in `estimateDelegateTxFee`!
-    // TODO: Submit these transactions as an atomic bundle.
-    if (waitForConfirmation) {
-      feeData = await getLatestFeeData()
+    const createTxBaseArgs = {
+      asset: asset.baseAsset,
+      walletAccount,
+      fromAddress: delegatorAddress.toString(),
+      amount: asset.baseAsset.currency.ZERO,
+      tipGasPrice,
+      gasPrice,
     }
+    const [unsignedTxApprove, unsignedTxDelegate] = await Promise.all([
+      asset.baseAsset.api.createTx({
+        ...createTxBaseArgs,
+        toAddress: stakingApi.polygonContract.address,
+        txInput: txApproveData,
+        gasLimit: approveGasLimit,
+        nonce: baseNonce,
+      }),
+      asset.baseAsset.api.createTx({
+        ...createTxBaseArgs,
+        toAddress: stakingApi.validatorShareContract.address,
+        txInput: txDelegateData,
+        gasLimit: estimatedDelegateGasLimit,
+        nonce: baseNonce + 1,
+      }),
+    ])
+
+    await maticDelegateSimulateTransactions({
+      asset,
+      unsignedTxApprove,
+      unsignedTxDelegate,
+      senderAddress: delegatorAddress.toString(),
+      revertOnSimulationError,
+    })
 
-    const txDelegateData = await stakingApi.delegate({ amount })
+    // Sign transactions
+    const [approveSigned, delegateSigned] = await Promise.all([
+      assetClientInterface.signTransaction({
+        assetName: asset.baseAsset.name,
+        unsignedTx: unsignedTxApprove.unsignedTx,
+        walletAccount,
+      }),
+      assetClientInterface.signTransaction({
+        assetName: asset.baseAsset.name,
+        unsignedTx: unsignedTxDelegate.unsignedTx,
+        walletAccount,
+      }),
+    ])
 
-    ;({ gasPrice, gasLimit, tipGasPrice } = await estimateTxFee({
-      from: delegatorAddress,
-      to: stakingApi.validatorShareContract.address,
-      txInput: txDelegateData,
-      feeData,
-    }))
+    // Pre-compute txIDs
+    const approveTxId = `0x${approveSigned.txId.toString('hex')}`
+    const delegateTxId = `0x${delegateSigned.txId.toString('hex')}`
 
-    const txId = await prepareAndSendTx({
-      walletAccount,
-      // TOOD: Why shouldn't we wait for confirmation here? Is it because we want to `notifyStaking`?
-      waitForConfirmation: false,
-      to: stakingApi.validatorShareContract.address,
-      txData: txDelegateData,
-      gasPrice,
-      gasLimit,
-      tipGasPrice,
-      feeData,
+    const bundleResponse = await asset.baseAsset.broadcastPrivateBundle({
+      txs: [approveSigned, delegateSigned].map(({ rawTx }) => rawTx),
     })
+    const bundleHash = bundleResponse?.bundleHash
+
+    const { optimisticTxLogEffects: approveOptimisticTxLogEffects } =
+      await getOptimisticTxLogEffects({
+        asset: asset.baseAsset,
+        assetClientInterface,
+        fromAddress: delegatorAddress.toString(),
+        txId: approveTxId,
+        unsignedTx: unsignedTxApprove.unsignedTx,
+        walletAccount,
+        bundleId: bundleHash ?? undefined,
+      })
+
+    const { optimisticTxLogEffects: delegateOptimisticTxLogEffects } =
+      await getOptimisticTxLogEffects({
+        asset: asset.baseAsset,
+        assetClientInterface,
+        fromAddress: delegatorAddress.toString(),
+        txId: delegateTxId,
+        unsignedTx: unsignedTxDelegate.unsignedTx,
+        walletAccount,
+        bundleId: bundleHash ?? undefined,
+      })
+    // Combine optimistic effects from both transactions
+    const tokenOptimisticEffects = [
+      ...approveOptimisticTxLogEffects,
+      ...delegateOptimisticTxLogEffects,
+    ]
+
+    for (const optimisticEffect of tokenOptimisticEffects) {
+      await assetClientInterface.updateTxLogAndNotify(optimisticEffect)
+    }
 
     await stakingProvider.notifyStaking({
-      txId,
+      txId: delegateTxId,
       asset: asset.name,
       delegator: delegatorAddress,
       amount: amount.toBaseString(),
     })
-
-    return txId
+    return delegateTxId
   }
 
-  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false } = {}) {
+  async function undelegate({ walletAccount, amount, feeData, waitForConfirmation = false }) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
@@ -177,7 +239,7 @@ export function createPolygonStakingService({
     })
   }
 
-  async function claimRewards({ walletAccount, feeData } = {}) {
+  async function claimRewards({ walletAccount, feeData }) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const [delegatorAddress, { stakingApi }] = await Promise.all([
@@ -203,7 +265,7 @@ export function createPolygonStakingService({
     })
   }
 
-  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData } = {}) {
+  async function claimUndelegatedBalance({ walletAccount, unbondNonce, feeData }) {
     feeData = await resolveOptionalFeeData({ feeData })
 
     const [delegatorAddress, { asset, stakingApi }] = await Promise.all([
@@ -301,7 +363,7 @@ export function createPolygonStakingService({
    * 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({ feeData } = {}) {
+  async function estimateDelegateTxFee({ feeData } = Object.create(null)) {
     // approx gas limits
     const { ethereum } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
@@ -346,7 +408,8 @@ export function createPolygonStakingService({
       gasPrice: DISABLE_BALANCE_CHECKS,
     })
 
-    return ethereum.api.getFee({ asset: ethereum, feeData, gasLimit, amount })
+    const fee = ethereum.api.getFee({ asset: ethereum, feeData, gasLimit, amount })
+    return { ...fee, gasLimit }
   }
 
   async function prepareAndSendTx({
@@ -358,7 +421,7 @@ export function createPolygonStakingService({
     tipGasPrice,
     waitForConfirmation = false,
     feeData,
-  } = {}) {
+  }) {
     const { ethereum: asset } = await assetClientInterface.getAssetsForNetwork({
       baseAssetName: 'ethereum',
     })

package/src/tx-log/get-optimistic-txlog-effects.js

@@ -4,6 +4,12 @@ import { isEthereumLikeToken, parseUnsignedTx } from '@exodus/ethereum-lib'
 import { bufferToHex } from '@exodus/ethereumjs/util'
 import assert from 'minimalistic-assert'
 
+import { MaticStakingApi } from '../staking/matic/api.js'
+import {
+  DELEGATE,
+  maticDelegateOptimisticSideEffectTxLogs,
+} from '../staking/matic/matic-staking-utils.js'
+
 // Returns the most competitively priced pending
 // transaction from the `TxLog` for a given `nonce`.
 //
@@ -50,6 +56,7 @@ export const getHighestIncentiveTxByNonce = async ({
 export const getOptimisticTxLogEffects = async ({
   asset,
   assetClientInterface,
+  bundleId,
   confirmations = 0,
   date = SynchronizedTime.now(),
   fromAddress,
@@ -108,6 +115,23 @@ export const getOptimisticTxLogEffects = async ({
     console.log('Attempting to replace a transaction using an insufficient fee!')
   }
 
+  // Contains effects for smart-contract initiated token movements.
+  const methodOptimisticSideEffects = await operationTxLogSideEffects({
+    txToAddress: to,
+    methodId,
+    asset,
+    walletAccount,
+    feeAmount,
+    txId,
+    nonce,
+    gasLimit,
+    tipGasPrice: maybeTipGasPrice,
+    data,
+    date,
+    bundleId,
+  })
+
+  // Fallback to basic logic that only handles transfers + fee decoding
   const sharedProps = {
     confirmations,
     date,
@@ -122,6 +146,7 @@ export const getOptimisticTxLogEffects = async ({
       nonce,
       ...(maybeTipGasPrice ? { tipGasPrice: maybeTipGasPrice.toBaseString() } : null),
       ...(methodId ? { methodId } : null),
+      ...(bundleId ? { bundleId } : null),
     },
   }
 
@@ -157,7 +182,48 @@ export const getOptimisticTxLogEffects = async ({
         },
       ],
     },
+    ...methodOptimisticSideEffects,
   ].filter(Boolean)
 
   return { optimisticTxLogEffects, nonce }
 }
+
+const operationTxLogSideEffects = async ({
+  txToAddress,
+  methodId,
+  asset,
+  walletAccount,
+  feeAmount,
+  txId,
+  nonce,
+  gasLimit,
+  tipGasPrice,
+  data,
+  date,
+  bundleId,
+}) => {
+  // Matic Delegate
+  if (
+    txToAddress?.toLowerCase() ===
+      MaticStakingApi.EVERSTAKE_VALIDATOR_CONTRACT_ADDR.toLowerCase() &&
+    methodId === DELEGATE
+  ) {
+    return maticDelegateOptimisticSideEffectTxLogs({
+      asset,
+      walletAccount,
+      feeAmount,
+      delegateTxId: txId,
+      nonce,
+      estimatedDelegateGasLimit: gasLimit,
+      tipGasPrice,
+      transactionData: data,
+      date,
+      bundleId,
+    })
+  }
+
+  // Add other officially supported operations here
+  // Then can fallback to simulation results (TODO)
+  // Then finally to the default basic logic
+  return []
+}

package/src/tx-log-staking-processor/utils.js

@@ -1,7 +1,9 @@
 import { asset as ethereum } from '@exodus/ethereum-meta'
 import { asset as ethereumholesky } from '@exodus/ethereumholesky-meta'
 
-import { EthereumStaking, isEthereumStakingTx, MaticStakingApi } from '../staking/index.js'
+import { EthereumStaking } from '../staking/ethereum/api.js'
+import { isEthereumStakingTx } from '../staking/ethereum/staking-utils.js'
+import { MaticStakingApi } from '../staking/matic/api.js'
 
 const polygonStakingApi = new MaticStakingApi()
 const ethereumStakingApi = new EthereumStaking(ethereum)