6153762427

Committed 12 Sep 2023 01:33AM UTC coverage: 2.938% (-97.1%) from 100.0%

Build # 6153762427

Build Type

push

github

Committed by

hexpaydaydev

Commit Message

Adjusted oracle estimation and test

Run Details

3 of 244 branches covered (0.0%)

Branch coverage included in aggregate %.

2 of 2 new or added lines in 1 file covered. (100.0%)

585 existing lines in 21 files now uncovered.

22 of 607 relevant lines covered (3.62%)

30.12 hits per line

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

0.0

/contracts/Magnitude.sol

1	// SPDX-License-Identifier: UNLICENSED
2	pragma solidity >=0.8.18;
3
4	import { Utils } from "./Utils.sol";
5	import { UnderlyingStakeable } from "./UnderlyingStakeable.sol";
6
7	contract Magnitude is Utils {
8	uint256 constant internal X_OPTIONS = THREE;
9	function _computeDayMagnitude(
10	uint256 limit, uint256 method, uint256 x,
11	uint256 today, // today
12	uint256 lockedDay, // lockedDay
13	uint256 stakedDays
14	) internal pure returns(uint256 amount) {
UNCOV 15	unchecked {	×
UNCOV 16	if (method < THREE) {	×
UNCOV 17	if (method == ONE) {	×
18	// useful when you want the next stake start to be
19	// entirely different and simply repeat after that
UNCOV 20	amount = x; // 1	×
21	} else {
UNCOV 22	amount = stakedDays; // 2 - repeat number of days	×
23	}
24	} else {
25	// 3 - start an equally spaced ladder, even if end stake happens late
UNCOV 26	uint256 daysAfterLock = today - lockedDay;	×
UNCOV 27	if (daysAfterLock == stakedDays) {	×
UNCOV 28	amount = stakedDays; // ended on first available day (most cases)	×
29	} else {
30	// did not end on first available day
31	// presumptive value extrapolated backward
UNCOV 32	lockedDay = today - (daysAfterLock % (stakedDays + ONE));	×
33	// else locked day was last presumptive locked day
UNCOV 34	amount = stakedDays - (today - lockedDay);	×
35	}
36	}
UNCOV 37	amount = amount > limit ? limit : amount;	×
38	}
39	}
40	/**
41	* compute a useful value from 2 inputs
42	* @param linear holds the linear data to describe how to plot a provied y value
43	* @param v2 a secondary magnitude to use - generally the amount of the end stake
44	* @param v1 the starting point of v2 used for deltas
45	* @notice funds may never be linked to x variable. X should only hold data that we can plug into
46	* an expression to tell us where to land on the plot. Result is never less than 0, nor greater than limit
47	*/
48	function _computeMagnitude(
49	uint256 limit, uint256 linear,
50	uint256 v2, uint256 v1
51	) internal pure returns(uint256 amount) {
52	// we can use unchecked here because all minuses (-)
53	// are checked before they are run
UNCOV 54	unchecked {	×
UNCOV 55	uint256 method = uint8(linear);	×
UNCOV 56	if (method < X_OPTIONS) {	×
UNCOV 57	if (method == ONE) {	×
UNCOV 58	amount = (uint256(uint56(linear >> EIGHT)) << uint256(uint8(linear >> SIXTY_FOUR))); // 1	×
59	} else {
UNCOV 60	amount = v2; // 2	×
61	}
62	} else {
UNCOV 63	Linear memory line = _decodeLinear(linear);	×
UNCOV 64	uint256 delta = _getDelta(line.method, v2, v1);	×
UNCOV 65	if (delta == ZERO) return ZERO;	×
66	// even with uint16 (max: 65535), we can still get down to 0.01% increments
67	// with scaling we can go even further (though it is choppier)
68	// x has an embedded 1 offset
UNCOV 69	int256 x = line.x << (line.xFactor - ONE);	×
UNCOV 70	uint256 y = line.y << line.yFactor;	×
UNCOV 71	int256 b = line.b << line.bFactor;	×
UNCOV 72	int256 amnt = ((x * int256(delta)) / int256(y)) + b;	×
UNCOV 73	amount = amnt < 0 ? ZERO : uint256(amnt);	×
74	}
UNCOV 75	amount = amount > limit ? limit : amount;	×
76	}
77	}
78	function _getDelta(uint256 method, uint256 v2, uint256 v1) internal pure returns(uint256 y) {
UNCOV 79	unchecked {	×
UNCOV 80	y = v2;	×
UNCOV 81	if (method == ONE) {	×
82	// v1 only
UNCOV 83	y = v1;	×
84	} else if (method == TWO) {	×
85	// yield only
UNCOV 86	if (v2 > v1) {	×
UNCOV 87	y = v2 - v1;	×
88	} else {
UNCOV 89	y = ZERO;	×
90	}
91	}
92	}
93	}
94	struct Linear {
95	uint256 method;
96	uint256 xFactor;
97	int256 x;
98	uint256 yFactor;
99	uint256 y;
100	uint256 bFactor;
101	int256 b;
102	}
103	function encodeLinear(Linear calldata linear) external pure returns(uint256 encoded) {
UNCOV 104	return _encodeLinear(linear);	×
105	}
106	/**
107	* convert an x/y+b linear struct into a number held in under 72 total bits
108	* @param linear the struct with all relevant linear data in it
109	* @return encoded the encoded numbers describing (x/y)+b
110	*/
111	function _encodeLinear(Linear memory linear) internal pure returns(uint256 encoded) {
UNCOV 112	if (linear.method >= X_OPTIONS) revert NotAllowed();	×
UNCOV 113	if (linear.xFactor == ZERO) {	×
UNCOV 114	return uint72(	×
115	uint256(linear.yFactor << SIXTY_FOUR)
116	\| uint256(uint56(linear.y << EIGHT))
117	\| uint256(uint8(linear.method))
118	);
119	}
120	// xFactor must be > 0
UNCOV 121	unchecked {	×
UNCOV 122	return uint256(	×
123	(uint256(uint16(int16(linear.x)) - uint16(int16(MIN_INT_16))) << FIFTY_SIX)
124	\| (uint256(uint8(linear.yFactor)) << FOURTY_EIGHT)
125	\| (uint256(uint16(linear.y)) << THIRTY_TWO)
126	\| (uint256(uint8(linear.bFactor)) << TWENTY_FOUR)
127	\| (uint256(uint16(int16(linear.b)) - uint16(int16(MIN_INT_16))) << EIGHT)
128	\| uint256(uint8((linear.xFactor * X_OPTIONS) + linear.method))
129	);
130	}
131	}
132	/**
133	* decode an b+(x/y) slope from a number and scale it to your preference
134	* @param encodedLinear holds all relevant data for filling out a Linear struct
135	* @return linear the full set of parameters to describe a (x/y)+b pattern
136	* @notice this limits the bFactor from scaling beyond 2^84, which should be enough for most use cases
137	*/
138	function decodeLinear(uint256 encodedLinear) external pure returns (Linear memory linear) {
UNCOV 139	return _decodeLinear({	×
140	encodedLinear: encodedLinear
141	});
142	}
143	function _decodeLinear(uint256 encodedLinear) internal pure returns (Linear memory linear) {
144	// only first 72 bits of magnitude are read / relevant for our purposes
UNCOV 145	unchecked {	×
UNCOV 146	uint256 method = uint8(encodedLinear);	×
UNCOV 147	linear.xFactor = method / X_OPTIONS;	×
UNCOV 148	linear.method = method % X_OPTIONS;	×
149	// when xFactor is 0, nothing below makes a difference except y
UNCOV 150	if (linear.xFactor == ZERO) {	×
151	// y is being used because it is the only uint
UNCOV 152	linear.y = (uint256(uint56(encodedLinear >> EIGHT)) << uint8(encodedLinear >> SIXTY_FOUR));	×
UNCOV 153	return linear;	×
154	}
155	// numerator
UNCOV 156	linear.x = int16(uint16(encodedLinear >> FIFTY_SIX)) + int16(-MIN_INT_16);	×
157	// denominator - uint
UNCOV 158	linear.yFactor = uint256(uint8(encodedLinear >> FOURTY_EIGHT)); // udd*(4^sfd)=d	×
UNCOV 159	linear.y = uint16(encodedLinear >> THIRTY_TWO);	×
160	// offset
UNCOV 161	linear.bFactor = uint256(uint8(encodedLinear >> TWENTY_FOUR)); // b*(2^sfn)=b	×
UNCOV 162	linear.b = int16(uint16(encodedLinear >> EIGHT)) + int16(-MIN_INT_16);	×
163	}
164	}
165	/**
166	* compute a magnitude given an x and y
167	* @param limit a limit that the uint result can not be greater than
168	* @param linear the linear data to describe an (x/y)+b relationship
169	* @param v2 the second value as input
170	* @param v1 the stake to use as an input for the second value
171	*/
172	function computeMagnitude(
173	uint256 limit, Linear calldata linear,
174	uint256 v2, uint256 v1
175	) external pure returns(uint256 result) {
UNCOV 176	if (limit == ZERO \|\| (linear.method == ZERO && linear.xFactor == ZERO)) {	×
UNCOV 177	return ZERO;	×
178	}
UNCOV 179	return _computeMagnitude({	×
180	limit: limit,
181	linear: _encodeLinear(linear),
182	v2: v2,
183	v1: v1
184	});
185	}
186	/**
187	* compute a day magnitude given an x and y
188	* @param limit a limit that the uint result can not be greater than
189	* @param method the method to use to compute the result
190	* @param x the first value as input
191	* @param today the hex day value
192	* @param lockedDay the day that the stake was locked
193	* @param stakedDays the number of full days that the stake was locked
194	*/
195	function computeDayMagnitude(
196	uint256 limit, uint256 method, uint256 x,
197	uint256 today,
198	uint256 lockedDay,
199	uint256 stakedDays
200	) external pure returns(uint256 result) {
UNCOV 201	if (limit == ZERO \|\| method == ZERO) {	×
UNCOV 202	return ZERO;	×
203	}
UNCOV 204	return _computeDayMagnitude({	×
205	limit: limit,
206	method: method,
207	x: x,
208	today: today,
209	lockedDay: lockedDay,
210	stakedDays: stakedDays
211	});
212	}
213	}

hexpay-day / stake-manager / 6153762427

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