ETH = int(1e18)

class OracleContract:

    LAST_PUSHED_EPOCH_ID = 0 # Need to be introduced. Absent currently.
    gatheredEpochData = {}

    # from beaconSpec. Production values. Frame = 1 day
    epochsPerFrame = 225
    secondsPerEpoch = 32 * 12

    """
    If we use APR as a basic reference for increase, and expected range is between 1 and 10% APR.
    So the granularity step for yearly APR is 1%
    daily_granularity = 0.01 / 365 = 2.74e-05
    Currently used basisPoints (1e-4) is unable to express such microscopic ratio.
    So we should take another popular metric to express this - PPM or 1e-6
    daily_granularity_in_ppm = 2.74e-05 / 1e-6 = 27 (pretty good)
    with 100% buffer for future spikes it will be 50
    """
    ALLOWED_BEACON_BALANCE_INCREASE = 50 # PPM

    """
    When slashing happens, the balance may decrease at a much faster pace.
    On the start the system will have about 100 validators and we can guess one of them can be slashed for any reason.
    1/100 = 10000 PPM
    """
    ALLOWED_BEACON_BALANCE_DECREASE = 10000 # PPM

    """
    Based on this analytics https://etherscan.io/address/0xae7ab96520de3a18e5e111b5eaab095312d7fe84#analytics 
    The max number of daily deposited validators is about 2000 ETH (19 Dec)
    Divide it by DEPOSIT_SIZE and get the number of daily activated validators 2000 / 32 = 62.5
    And we leave 50-percent buffer for possible short-time bursts ~= 100 
    """
    ALLOWED_BEACON_VALIDATORS_DAILY_INCREASE = 100 # validators


    def reportBeacon(self, _epochId, _beaconBalance, _beaconValidators):

        if self._check_constraints(_epochId, _beaconBalance, _beaconValidators):
            self.LAST_REPORTED_EPOCH_ID = _epochId
            self.gatheredEpochData = (_beaconBalance, _beaconValidators)
            return True # Push to lido
        else:
            return False

    def setAllowedBeaconBalanceIncrease(self, _ppmPerDay):
        pass

    def setAllowedBeaconBalanceDecrease(self, _ppmPerDay):
        pass

    def setAllowedBeaconvalidatorsIncrease(self, _validatorsPerDay):
        pass

    def _check_constraints(self, _epochId, _beaconBalance, _beaconValidators):
        """Check the received numbers satisfy change boundaries"""
        DAY = 60 * 60 * 24
        epoch_delta = _epochId - self.LAST_PUSHED_EPOCH_ID
        seconds_since_last_pushed_epoch = epoch_delta * self.secondsPerEpoch
        
        last_pushed_beaconValidators = self.gatheredEpochData[self.LAST_PUSHED_EPOCH_ID][1]
        validators_upper_boundary = last_pushed_beaconValidators + seconds_since_last_pushed_epoch * self.ALLOWED_BEACON_VALIDATORS_DAILY_INCREASE / DAY
        if _beaconValidators > validators_upper_boundary:
            return False # Revert with human-readable reason
        
        last_pushed_beaconBalance = self.gatheredEpochData[self.LAST_PUSHED_EPOCH_ID][0]
        beacon_balance_upper_boundary = last_pushed_beaconBalance + seconds_since_last_pushed_epoch * last_pushed_beaconBalance * self.ALLOWED_BEACON_BALANCE_INCREASE / DAY / 1e6
        beacon_balance_lower_boundary = last_pushed_beaconBalance - seconds_since_last_pushed_epoch * last_pushed_beaconBalance * self.ALLOWED_BEACON_BALANCE_DECREASE / DAY / 1e6
        if beacon_balance_lower_boundary <= _beaconBalance <= beacon_balance_upper_boundary:
            return True
        
        return False # Revert with human-readable reason

def test_report_beacon_balance_and_validators_unchanged():
    o = OracleContract()
    o.gatheredEpochData[0] = (100000 * ETH, 100)
    assert o.reportBeacon(225, 100000 * ETH, 100)

def test_report_beacon_balance_allowed_increase():
    o = OracleContract()
    o.gatheredEpochData[0] = (100000 * ETH, 100)
    assert o.reportBeacon(225, 100004 * ETH, 100) # one day later

def test_report_beacon_balance_too_much_increase():
    o = OracleContract()
    o.gatheredEpochData[0] = (100000 * ETH, 100)
    assert o.reportBeacon(225, 100006 * ETH, 100) == False # one day later

def test_report_beacon_balance_allowed_decrease():
    o = OracleContract()
    o.gatheredEpochData[0] = (100000 * ETH, 100)
    assert o.reportBeacon(225, 99000 * ETH, 100) # one day later

def test_report_beacon_balance_too_much_decrease():
    o = OracleContract()
    o.gatheredEpochData[0] = (100000 * ETH, 100)
    assert o.reportBeacon(225, 98000 * ETH, 100) == False # one day later

def test_report_beacon_validators_allowed_increase():
    o = OracleContract()
    o.gatheredEpochData[0] = (100000 * ETH, 100)
    assert o.reportBeacon(225, 100004 * ETH, 199) # one day later

DEPOSIT_SIZE = 32 ether
appeared_validators = current.beaconValidators - previous.beaconValidator
reward_base = appeared_validators * DEPOSIT_SIZE + previous.beaconBalance
reward = current.beaconBalance - reward_base
apr_ppm = 1e6 * reward / ( reward_base * 1 years / elapsedTime )