| 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161 |
113×
113×
113×
113×
113×
113×
113×
113×
113×
182×
182×
182×
182×
177×
177×
177×
182×
182×
182×
39×
39×
39×
36×
36×
36×
259×
305×
213×
213×
213×
193×
193×
20×
20×
20×
20×
| // SPDX-License-Identifier: BlueOak-1.0.0
pragma solidity 0.8.17;
import "../../p1/mixins/RecollateralizationLib.sol";
import "../../interfaces/IMain.sol";
import "../../interfaces/IRToken.sol";
import "./Asset.sol";
/// Once an RToken gets large enough to get a price feed, replacing this asset with
/// a simpler one will do wonders for gas usage
contract RTokenAsset is IAsset {
using FixLib for uint192;
using OracleLib for AggregatorV3Interface;
// Component addresses are not mutable in protocol, so it's safe to cache these
IBasketHandler public immutable basketHandler;
IAssetRegistry public immutable assetRegistry;
IBackingManager public immutable backingManager;
IERC20Metadata public immutable erc20;
uint8 public immutable erc20Decimals;
uint192 public immutable override maxTradeVolume; // {UoA}
/// @param maxTradeVolume_ {UoA} The max trade volume, in UoA
constructor(IRToken erc20_, uint192 maxTradeVolume_) {
Erequire(address(erc20_) != address(0), "missing erc20");
Erequire(maxTradeVolume_ > 0, "invalid max trade volume");
IMain main = erc20_.main();
basketHandler = main.basketHandler();
assetRegistry = main.assetRegistry();
backingManager = main.backingManager();
erc20 = IERC20Metadata(address(erc20_));
erc20Decimals = erc20_.decimals();
maxTradeVolume = maxTradeVolume_;
}
/// Can revert, used by other contract functions in order to catch errors
/// @return low {UoA/tok} The low price estimate
/// @return high {UoA/tok} The high price estimate
function tryPrice() external view virtual returns (uint192 low, uint192 high) {
(uint192 lowBUPrice, uint192 highBUPrice) = basketHandler.price(); // {UoA/BU}
assert(lowBUPrice <= highBUPrice); // not obviously true just by inspection
// Here we take advantage of the fact that we know RToken has 18 decimals
// to convert between uint256 an uint192. Fits due to assumed max totalSupply.
uint192 supply = _safeWrap(IRToken(address(erc20)).totalSupply());
if (supply == 0) return (lowBUPrice, highBUPrice);
// The RToken's price is not symmetric like other assets!
// range.bottom is lower because of the slippage from the shortfall
BasketRange memory range = basketRange(); // {BU}
// {UoA/tok} = {BU} * {UoA/BU} / {tok}
low = range.bottom.mulDiv(lowBUPrice, supply, FLOOR);
high = range.top.mulDiv(highBUPrice, supply, CEIL);
// assert(low <= high); // obviously true at this point just by inspection
}
// solhint-disable no-empty-blocks
function refresh() public virtual override {
// No need to save lastPrice; can piggyback off the backing collateral's lotPrice()
}
// solhint-enable no-empty-blocks
/// Should not revert
/// @return {UoA/tok} The lower end of the price estimate
/// @return {UoA/tok} The upper end of the price estimate
function price() public view virtual returns (uint192, uint192) {
try this.tryPrice() returns (uint192 low, uint192 high) {
assert(low <= high);
return (low, high);
} catch (bytes memory errData) {
// see: docs/solidity-style.md#Catching-Empty-Data
if (errData.length == 0) revert(); // solhint-disable-line reason-string
return (0, FIX_MAX);
}
}
/// Should not revert
/// lotLow should be nonzero when the asset might be worth selling
/// @return lotLow {UoA/tok} The lower end of the lot price estimate
/// @return lotHigh {UoA/tok} The upper end of the lot price estimate
function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh) {
(uint192 buLow, uint192 buHigh) = basketHandler.lotPrice(); // {UoA/BU}
// Here we take advantage of the fact that we know RToken has 18 decimals
// to convert between uint256 an uint192. Fits due to assumed max totalSupply.
uint192 supply = _safeWrap(IRToken(address(erc20)).totalSupply());
if (supply == 0) return (buLow, buHigh);
BasketRange memory range = basketRange(); // {BU}
// {UoA/tok} = {BU} * {UoA/BU} / {tok}
lotLow = range.bottom.mulDiv(buLow, supply);
lotHigh = range.top.mulDiv(buHigh, supply);
}
/// @return {tok} The balance of the ERC20 in whole tokens
function bal(address account) external view returns (uint192) {
// The RToken has 18 decimals, so there's no reason to waste gas here doing a shiftl_toFix
// return shiftl_toFix(erc20.balanceOf(account), -int8(erc20Decimals));
return _safeWrap(erc20.balanceOf(account));
}
/// @return If the asset is an instance of ICollateral or not
function isCollateral() external pure virtual returns (bool) {
return false;
}
// solhint-disable no-empty-blocks
/// Claim rewards earned by holding a balance of the ERC20 token
/// @dev Use delegatecall
function claimRewards() external virtual {}
// solhint-enable no-empty-blocks
// ==== Private ====
function basketRange() private view returns (BasketRange memory range) {
BasketRange memory basketsHeld = basketHandler.basketsHeldBy(address(backingManager));
uint192 basketsNeeded = IRToken(address(erc20)).basketsNeeded(); // {BU}
// if (basketHandler.fullyCollateralized())
if (basketsHeld.bottom >= basketsNeeded) {
range.bottom = basketsNeeded;
range.top = basketsNeeded;
} else {
// Note: Extremely this is extremely wasteful in terms of gas. This only exists so
// there is _some_ asset to represent the RToken itself when it is deployed, in
// the absence of an external price feed. Any RToken that gets reasonably big
// should switch over to an asset with a price feed.
IMain main = backingManager.main();
TradingContext memory ctx = TradingContext({
basketsHeld: basketsHeld,
bm: backingManager,
bh: main.basketHandler(),
reg: main.assetRegistry(),
stRSR: main.stRSR(),
rsr: main.rsr(),
rToken: main.rToken(),
minTradeVolume: backingManager.minTradeVolume(),
maxTradeSlippage: backingManager.maxTradeSlippage()
});
Registry memory reg = assetRegistry.getRegistry();
// will exclude UoA value from RToken balances at BackingManager
range = RecollateralizationLibP1.basketRange(ctx, reg);
}
}
}
|