6053801278

Committed 01 Sep 2023 08:39PM UTC coverage: 97.462% (+0.1%) from 97.358%

Build # 6053801278

Build Type

push

github

Committed by

hexpaydaydev

Commit Message

Refactors tipper method to remove unused method

Run Details

211 of 230 branches covered (0.0%)

Branch coverage included in aggregate %.

18 of 18 new or added lines in 2 files covered. (100.0%)

1 existing line in 1 file now uncovered.

557 of 558 relevant lines covered (99.82%)

116.39 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.67

/contracts/EarningsOracle.sol

// SPDX-License-Identifier: UNLICENSED
pragma solidity =0.8.18;

import { IHEX } from './interfaces/IHEX.sol';
import { Utils } from './Utils.sol';

contract EarningsOracle is Utils {
  uint256 public immutable lastZeroDay;
  /**
   * @dev this max constraint is very generous given that
   * the sstore opcode costs ~20k gas at the time of writing
   */
  uint256 public constant MAX_CATCH_UP_DAYS = 1_000;
  uint256 public constant MAX_UINT_128 = type(uint128).max;
  uint256 public constant SHARE_SCALE = 1e5;
  TotalStore[] public totals;
  struct TotalStore {
    uint128 payout;
    uint128 shares;
  }
  struct Total {
    uint256 payout;
    uint256 shares;
  }
  /**
   * deploy contract and start collecting data immediately.
   * pass 0 for untilDay arg to skip collection and start with nothing in payoutTotal array
   * @param _lastZeroDay the final day to allow zero value (used to filter out empty values)
   * @param untilDay the day to end collection
   */
  constructor(uint256 _lastZeroDay, uint256 untilDay) {
    lastZeroDay = _lastZeroDay;
    if (untilDay > ZERO) {
      _storeDays({
        startDay: 0,
        untilDay: untilDay
      });
    }
  }
  /**
   * the size of the payoutTotal array - correlates to days stored
   */
  function totalsCount() external view returns(uint256 count) {
    return totals.length;
  }
  /**
   * the delta between two days. untilDay argument must be greater
   * than startDay argument otherwise call may fail
   * @param startDay the day to start counting from
   * @param untilDay the day to end with (inclusive)
   */
  function payoutDelta(uint256 startDay, uint256 untilDay) external view returns(uint256 payout, uint256 shares) {
    TotalStore memory start = totals[startDay];
    TotalStore memory until = totals[untilDay];
    unchecked {
      return (
        until.payout - start.payout,
        until.shares - start.shares
      );
    }
  }
  /**
   * multiply the difference of the payout by a constant and divide that result by the denominator
   * subtract half of the difference between the two days to find the possible lower bound
   * @param startDay the day to start counting
   * @param untilDay the day to stop counting
   * @param multiplier a number to multiply by the difference of the payout
   */
  function payoutDeltaTrucated(
    uint256 startDay,
    uint256 untilDay,
    uint256 multiplier
  ) external view returns(uint256 payout) {
    return ((
      (totals[untilDay].payout - totals[startDay].payout) * multiplier * (untilDay - startDay)
    ) / (
      totals[untilDay].shares - totals[startDay].shares
    )) - (
      // for a 1 day span, the amount is actually known
      (untilDay - startDay) - 1
    );
  }
  /**
   * store the payout total for a given day. day must be the next day in the sequence (start with 0)
   * day must have data available to read from the hex contract
   * @param day the day being targeted
   * @param total the total payout logged in the previous day
   * @dev the _total arg must be handled internally - cannot be passed from external
   */
  function _storeDay(uint256 day, Total memory _total) internal returns(Total memory total) {
    (
      uint256 dayPayoutTotal,
      uint256 dayStakeSharesTotal,
      // uint256 dayUnclaimedSatoshisTotal
    ) = IHEX(TARGET).dailyData({
      day: day
    });
    if (day > lastZeroDay && dayStakeSharesTotal == 0) {
      // stake data is not yet set
      revert NotAllowed();
    }
    (uint256 payout, uint256 shares) = _readTotals(day, _total);
    return _saveDay(dayPayoutTotal + payout, dayStakeSharesTotal + shares);
  }
  function _readTotals(uint256 day, Total memory _total) internal view returns(uint256 payout, uint256 shares) {
    (payout, shares) = (_total.payout, _total.shares);
    if (payout == ZERO && shares == ZERO && day > ZERO) {
      TotalStore memory prev = totals[day - ONE];
      payout = prev.payout;
      shares = prev.shares;
    }
  }
  function _saveDay(uint256 payout, uint256 shares) internal returns(Total memory total) {
    total.payout = payout;
    total.shares = shares;
    // coveralls-ignore-start
    if (payout > MAX_UINT_128 || shares > MAX_UINT_128) {
      // this line is very difficult to test, so it is going to be skipped
      // until an easy way to test it can be devised for low effort
      // basically hex would have to break for the line to be hit
      // total supply: 59004373824667548121*20% - for the staked hex
      // total shares on any given day: 9828590775299543795 (<2^72-1 as maximum)
      // inflation rate: 3.69% maximum
      // assume 200 years
      // 59004373824667548121*(1.0369^200) << 2^128-1
      // ((2^72)-1)*365*200 << 2^128-1
      revert NotAllowed();
    }
    // coveralls-ignore-stop
    totals.push(TotalStore({
      payout: uint128(payout),
      shares: uint128(shares)
    }));
  }
  /**
   * store a singular day, only the next day in the sequence is allowed
   * @param day the day to store
   */
  function storeDay(uint256 day) external returns(Total memory total) {
    if (totals.length != day) {
      revert NotAllowed();
    }
    return _storeDay({
      day: day,
      _total: Total(0, 0)
    });
  }
  /**
   * checks the current day and increments the stored days if not yet covered
   */
  function incrementDay() external returns(Total memory total, uint256 day) {
    uint256 size = totals.length;
    if (size >= IHEX(TARGET).currentDay()) {
      // no need to increment
      return (total, 0);
    }
    return (_storeDay({
      day: size,
      _total: Total(0, 0)
    }), size);
  }
  /**
   * store a range of day payout information. untilDay is exclusive unless startDay and untilDay match
   * @param startDay the day to start storing day information
   * @param untilDay the day to stop storing day information
   */
  function _storeDays(uint256 startDay, uint256 untilDay) internal returns(Total memory total, uint256 day) {
    uint256[] memory range = IHEX(TARGET).dailyDataRange(startDay, untilDay);
    uint256 len = range.length;
    uint256 payout;
    uint256 shares;
    uint256 i;
    do {
      (payout, shares) = _readTotals(startDay, total);
      unchecked {
        payout += uint72(range[i]);
        shares += uint72(range[i] >> SEVENTY_TWO);
        total = _saveDay(payout, shares);
        ++i;
        ++startDay;
      }
    } while (i < len);
    return (Total(payout, shares), startDay);
  }
  /**
   * store a range of day payout information. range is not constrained by max catch up days constant
   * nor is it constrained to the current day so if it goes beyond the current day or has not yet been stored
   * then it is subject to failure
   * @param startDay the day to start storing day information
   * @param untilDay the day to stop storing day information. Until day is inclusive
   */
  function storeDays(uint256 startDay, uint256 untilDay) external returns(Total memory total, uint256 day) {
    uint256 size = totals.length;
    if (startDay != size) {
      startDay = size;
    }
    if (untilDay <= size) {
      return (Total(totals[untilDay].payout, totals[untilDay].shares), untilDay);
    }
    return _storeDays({
      startDay: startDay,
      untilDay: untilDay
    });
  }
  /**
   * catch up the contract by reading up to 1_000 days of payout information at a time
   * @param iterations the maximum number of days to iterate over - capped at 1_000 due to sload constraints
   */
  function catchUpDays(uint256 iterations) external returns(Total memory total, uint256 day) {
    // constrain by gas costs
    iterations = iterations == 0 || iterations > MAX_CATCH_UP_DAYS ? MAX_CATCH_UP_DAYS : iterations;
    uint256 startDay = totals.length;
    // constrain by size
    uint256 limit = IHEX(TARGET).currentDay();
    uint256 untilDay = startDay + iterations;
    if (untilDay > limit) {
      untilDay = limit;
    }
    return _storeDays({
      startDay: startDay,
      // iterations is used as untilDay to reduce number of variables in stack
      untilDay: untilDay
    });
  }
}

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity =0.8.18;
3
4	import { IHEX } from './interfaces/IHEX.sol';
5	import { Utils } from './Utils.sol';
6
7	contract EarningsOracle is Utils {
8	uint256 public immutable lastZeroDay;
9	/**
10	* @dev this max constraint is very generous given that
11	* the sstore opcode costs ~20k gas at the time of writing
12	*/
13	uint256 public constant MAX_CATCH_UP_DAYS = 1_000;
14	uint256 public constant MAX_UINT_128 = type(uint128).max;
15	uint256 public constant SHARE_SCALE = 1e5;
16	TotalStore[] public totals;
17	struct TotalStore {
18	uint128 payout;
19	uint128 shares;
20	}
21	struct Total {
22	uint256 payout;
23	uint256 shares;
24	}
25	/**
26	* deploy contract and start collecting data immediately.
27	* pass 0 for untilDay arg to skip collection and start with nothing in payoutTotal array
28	* @param _lastZeroDay the final day to allow zero value (used to filter out empty values)
29	* @param untilDay the day to end collection
30	*/
31	constructor(uint256 _lastZeroDay, uint256 untilDay) {
32	lastZeroDay = _lastZeroDay;	30✔
33	if (untilDay > ZERO) {	30✔
34	_storeDays({	6✔
35	startDay: 0,
36	untilDay: untilDay
37	});
38	}
39	}
40	/**
41	* the size of the payoutTotal array - correlates to days stored
42	*/
43	function totalsCount() external view returns(uint256 count) {
44	return totals.length;	66✔
45	}
46	/**
47	* the delta between two days. untilDay argument must be greater
48	* than startDay argument otherwise call may fail
49	* @param startDay the day to start counting from
50	* @param untilDay the day to end with (inclusive)
51	*/
52	function payoutDelta(uint256 startDay, uint256 untilDay) external view returns(uint256 payout, uint256 shares) {
53	TotalStore memory start = totals[startDay];	8✔
54	TotalStore memory until = totals[untilDay];	8✔
55	unchecked {	6✔
56	return (	6✔
57	until.payout - start.payout,
58	until.shares - start.shares
59	);
60	}
61	}
62	/**
63	* multiply the difference of the payout by a constant and divide that result by the denominator
64	* subtract half of the difference between the two days to find the possible lower bound
65	* @param startDay the day to start counting
66	* @param untilDay the day to stop counting
67	* @param multiplier a number to multiply by the difference of the payout
68	*/
69	function payoutDeltaTrucated(
70	uint256 startDay,
71	uint256 untilDay,
72	uint256 multiplier
73	) external view returns(uint256 payout) {
74	return ((	4✔
75	(totals[untilDay].payout - totals[startDay].payout) * multiplier * (untilDay - startDay)
76	) / (
77	totals[untilDay].shares - totals[startDay].shares
78	)) - (
79	// for a 1 day span, the amount is actually known
80	(untilDay - startDay) - 1
81	);
82	}
83	/**
84	* store the payout total for a given day. day must be the next day in the sequence (start with 0)
85	* day must have data available to read from the hex contract
86	* @param day the day being targeted
87	* @param total the total payout logged in the previous day
88	* @dev the _total arg must be handled internally - cannot be passed from external
89	*/
90	function _storeDay(uint256 day, Total memory _total) internal returns(Total memory total) {
91	(	28✔
92	uint256 dayPayoutTotal,
93	uint256 dayStakeSharesTotal,
94	// uint256 dayUnclaimedSatoshisTotal
95	) = IHEX(TARGET).dailyData({
96	day: day
97	});
98	if (day > lastZeroDay && dayStakeSharesTotal == 0) {	28✔
99	// stake data is not yet set
100	revert NotAllowed();	2✔
101	}
102	(uint256 payout, uint256 shares) = _readTotals(day, _total);	26✔
103	return _saveDay(dayPayoutTotal + payout, dayStakeSharesTotal + shares);	26✔
104	}
105	function _readTotals(uint256 day, Total memory _total) internal view returns(uint256 payout, uint256 shares) {
106	(payout, shares) = (_total.payout, _total.shares);	8,322✔
107	if (payout == ZERO && shares == ZERO && day > ZERO) {	8,322✔
108	TotalStore memory prev = totals[day - ONE];	46✔
109	payout = prev.payout;	46✔
110	shares = prev.shares;	46✔
111	}
112	}
113	function _saveDay(uint256 payout, uint256 shares) internal returns(Total memory total) {
114	total.payout = payout;	8,322✔
115	total.shares = shares;	8,322✔
116	// coveralls-ignore-start
117	if (payout > MAX_UINT_128 \|\| shares > MAX_UINT_128) {	8,322!
118	// this line is very difficult to test, so it is going to be skipped
119	// until an easy way to test it can be devised for low effort
120	// basically hex would have to break for the line to be hit
121	// total supply: 59004373824667548121*20% - for the staked hex
122	// total shares on any given day: 9828590775299543795 (<2^72-1 as maximum)
123	// inflation rate: 3.69% maximum
124	// assume 200 years
125	// 59004373824667548121*(1.0369^200) << 2^128-1
126	// ((2^72)-1)365200 << 2^128-1
UNCOV 127	revert NotAllowed();	×
128	}
129	// coveralls-ignore-stop
130	totals.push(TotalStore({	8,322✔
131	payout: uint128(payout),
132	shares: uint128(shares)
133	}));
134	}
135	/**
136	* store a singular day, only the next day in the sequence is allowed
137	* @param day the day to store
138	*/
139	function storeDay(uint256 day) external returns(Total memory total) {
140	if (totals.length != day) {	12✔
141	revert NotAllowed();	4✔
142	}
143	return _storeDay({	8✔
144	day: day,
145	_total: Total(0, 0)
146	});
147	}
148	/**
149	* checks the current day and increments the stored days if not yet covered
150	*/
151	function incrementDay() external returns(Total memory total, uint256 day) {
152	uint256 size = totals.length;	22✔
153	if (size >= IHEX(TARGET).currentDay()) {	22✔
154	// no need to increment
155	return (total, 0);	2✔
156	}
157	return (_storeDay({	20✔
158	day: size,
159	_total: Total(0, 0)
160	}), size);
161	}
162	/**
163	* store a range of day payout information. untilDay is exclusive unless startDay and untilDay match
164	* @param startDay the day to start storing day information
165	* @param untilDay the day to stop storing day information
166	*/
167	function _storeDays(uint256 startDay, uint256 untilDay) internal returns(Total memory total, uint256 day) {
168	uint256[] memory range = IHEX(TARGET).dailyDataRange(startDay, untilDay);	28✔
169	uint256 len = range.length;	28✔
170	uint256 payout;	28✔
171	uint256 shares;	28✔
172	uint256 i;	28✔
173	do {	28✔
174	(payout, shares) = _readTotals(startDay, total);
175	unchecked {
176	payout += uint72(range[i]);
177	shares += uint72(range[i] >> SEVENTY_TWO);
178	total = _saveDay(payout, shares);
179	++i;
180	++startDay;
181	}
182	} while (i < len);
183	return (Total(payout, shares), startDay);	28✔
184	}
185	/**
186	* store a range of day payout information. range is not constrained by max catch up days constant
187	* nor is it constrained to the current day so if it goes beyond the current day or has not yet been stored
188	* then it is subject to failure
189	* @param startDay the day to start storing day information
190	* @param untilDay the day to stop storing day information. Until day is inclusive
191	*/
192	function storeDays(uint256 startDay, uint256 untilDay) external returns(Total memory total, uint256 day) {
193	uint256 size = totals.length;	12✔
194	if (startDay != size) {	12✔
195	startDay = size;	8✔
196	}
197	if (untilDay <= size) {	12✔
198	return (Total(totals[untilDay].payout, totals[untilDay].shares), untilDay);	4✔
199	}
200	return _storeDays({	8✔
201	startDay: startDay,
202	untilDay: untilDay
203	});
204	}
205	/**
206	* catch up the contract by reading up to 1_000 days of payout information at a time
207	* @param iterations the maximum number of days to iterate over - capped at 1_000 due to sload constraints
208	*/
209	function catchUpDays(uint256 iterations) external returns(Total memory total, uint256 day) {
210	// constrain by gas costs
211	iterations = iterations == 0 \|\| iterations > MAX_CATCH_UP_DAYS ? MAX_CATCH_UP_DAYS : iterations;	14✔
212	uint256 startDay = totals.length;	14✔
213	// constrain by size
214	uint256 limit = IHEX(TARGET).currentDay();	14✔
215	uint256 untilDay = startDay + iterations;	14✔
216	if (untilDay > limit) {	14✔
217	untilDay = limit;	2✔
218	}
219	return _storeDays({	14✔
220	startDay: startDay,
221	// iterations is used as untilDay to reduce number of variables in stack
222	untilDay: untilDay
223	});
224	}
225	}

hexpay-day / stake-manager / 6053801278

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous