Profitability Engine Implementation

[0xSero]

Implement Profitability Engine for Bump Operations

Overview

Implement the Profitability Engine component that determines whether a deposit can be profitably bumped, considering calculator eligibility, reward constraints, gas costs, and batch optimization. This component will utilize the BinaryEligibilityCalculator we've implemented for determining initial bump eligibility.

Key Requirements

1. Bump Qualification Checks

• Integrate with BinaryEligibilityCalculator:

  // Use existing calculator implementation
  class BinaryEligibilityCalculator extends BaseCalculator {
    getNewEarningPower(
      amountStaked: BigNumber,
      staker: string,
      delegatee: string,
      oldEarningPower: BigNumber
    ): Promise<[BigNumber, boolean]>
  }

• Implement core validation for bump eligibility:
  • Use calculator's getNewEarningPower() to check initial eligibility
  • Validate unclaimed rewards sufficiency based on earning power change:
    • For power increases: unclaimedRewards >= requestedTip
    • For power decreases: unclaimedRewards - tip >= maxBumpTip
  • Ensure tip doesn't exceed maxBumpTip

2. Profitability Calculations

• Implement comprehensive profitability determination:

  class ProfitabilityEngine {
    constructor(
      private readonly calculator: BinaryEligibilityCalculator,
      private readonly stakerContract: Contract
    ) {}
  
    async checkProfitability(deposit: Deposit): Promise<ProfitabilityCheck> {
      // Use calculator for initial eligibility
      const [newPower, isEligible] = await this.calculator.getNewEarningPower(
        deposit.balance,
        deposit.staker,
        deposit.delegatee,
        deposit.earningPower
      )
  
      // Then check rewards and profitability...
    }
  }
  
  interface ProfitabilityCheck {
    canBump: boolean
    constraints: {
      calculatorEligible: boolean
      hasEnoughRewards: boolean
      isProfitable: boolean
    }
    estimates: {
      optimalTip: BigNumber
      gasEstimate: BigNumber
      expectedProfit: BigNumber
    }
  }

3. Batch Analysis

• Implement batch profitability analysis:
  • Group deposits for optimal gas usage
  • Calculate aggregate profitability
  • Consider gas price impact
  • Prioritize deposits within batch
  • Use calculator for batch eligibility checks

Technical Implementation

Core Methods

class ProfitabilityEngine {
  constructor(
    private readonly calculator: BinaryEligibilityCalculator,
    private readonly stakerContract: Contract,
    private readonly gasPriceOracle: GasPriceOracle
  ) {}

  // Core validation
  async validateBumpRequirements(
    deposit: Deposit,
    tipAmount: BigNumber
  ): Promise<BumpRequirements>

  // Tip optimization
  async calculateOptimalTip(
    deposit: Deposit,
    gasPrice: BigNumber
  ): Promise<TipOptimization>

  // Batch analysis
  async analyzeBatchProfitability(
    deposits: Deposit[],
    gasPrice: BigNumber
  ): Promise<BatchAnalysis>
}

Calculator Integration Points

• Use calculator's core methods:

  // Initial eligibility check
  getNewEarningPower()
  
  // Helper methods
  getDelegateScore()
  isEligible()
  getUpdateDelay()

Required Contract Interactions

• Integration with Staker contract:
  • unclaimedReward(depositId)
  • maxBumpTip()
• Integration with Calculator contract via BinaryEligibilityCalculator
• Gas price oracle integration

Dependencies

• BinaryEligibilityCalculator implementation
• Staker contract interface
• Gas price oracle
• Event monitoring system

Notes

• Reference the bumpEarningPower method in Staker.sol for exact validation rules
• Use the BinaryEligibilityCalculator for all calculator-related checks
• Consider gas price volatility in profitability calculations
• Implement proper error handling and logging
• Consider implementing monitoring for profitability metrics

[0xSero]

closed by: #13