컴파일러
0.8.19+commit.7dd6d404
파일 1 / 41 : ActFacet.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "../../plugins/trading/DutchTrade.sol";
import "../../plugins/trading/GnosisTrade.sol";
import "../../interfaces/IActFacet.sol";
import "../../interfaces/IBackingManager.sol";
contract ActFacet is IActFacet, Multicall {
using Address for address;
using SafeERC20 for IERC20;
using FixLib for uint192;
function claimRewards(IRToken rToken) external {
IMain main = rToken.main();
main.backingManager().claimRewards();
main.rTokenTrader().claimRewards();
main.rsrTrader().claimRewards();
}
function runRevenueAuctions(
IRevenueTrader revenueTrader,
IERC20[] calldata toSettle,
IERC20[] calldata toStart,
TradeKind[] calldata kinds
) external {
for (uint256 i = 0; i < toSettle.length; ++i) {
_settleTrade(revenueTrader, toSettle[i]);
}
bytes1 majorVersion = bytes(revenueTrader.version())[0];
if (toSettle.length > 0 && (majorVersion == bytes1("2") || majorVersion == bytes1("1"))) {
address(revenueTrader).functionCall(
abi.encodeWithSignature("manageToken(address)", revenueTrader.tokenToBuy())
);
}
if (toStart.length == 0) return;
_forwardRevenue(revenueTrader.main().backingManager(), toStart);
_runRevenueAuctions(revenueTrader, toStart, kinds);
}
function revenueOverview(IRevenueTrader revenueTrader)
external
returns (
IERC20[] memory erc20s,
bool[] memory canStart,
uint256[] memory surpluses,
uint256[] memory minTradeAmounts,
uint256[] memory bmRewards,
uint256[] memory revTraderRewards
)
{
IBackingManager bm = revenueTrader.main().backingManager();
uint192 minTradeVolume = revenueTrader.minTradeVolume();
Registry memory reg = revenueTrader.main().assetRegistry().getRegistry();
_forwardRevenue(bm, reg.erc20s);
erc20s = new IERC20[](reg.erc20s.length);
canStart = new bool[](reg.erc20s.length);
surpluses = new uint256[](reg.erc20s.length);
minTradeAmounts = new uint256[](reg.erc20s.length);
bmRewards = new uint256[](reg.erc20s.length);
revTraderRewards = new uint256[](reg.erc20s.length);
for (uint256 i = 0; i < reg.erc20s.length; ++i) {
erc20s[i] = reg.erc20s[i];
ITrade trade = revenueTrader.trades(erc20s[i]);
if (address(trade) != address(0) && trade.canSettle()) {
_settleTrade(revenueTrader, erc20s[i]);
}
surpluses[i] = erc20s[i].balanceOf(address(revenueTrader));
(uint192 low, ) = reg.assets[i].price();
if (low == 0) continue;
minTradeAmounts[i] = minTradeVolume.safeDiv(low, FLOOR).shiftl_toUint(
int8(reg.assets[i].erc20Decimals())
);
if (
surpluses[i] > minTradeAmounts[i] &&
revenueTrader.trades(erc20s[i]) == ITrade(address(0))
) {
canStart[i] = true;
}
}
for (uint256 i = 0; i < reg.erc20s.length; ++i) {
bmRewards[i] = reg.erc20s[i].balanceOf(address(bm));
}
try bm.claimRewards() {} catch {}
for (uint256 i = 0; i < reg.erc20s.length; ++i) {
bmRewards[i] = reg.erc20s[i].balanceOf(address(bm)) - bmRewards[i];
}
for (uint256 i = 0; i < reg.erc20s.length; ++i) {
revTraderRewards[i] = reg.erc20s[i].balanceOf(address(revenueTrader));
}
try revenueTrader.claimRewards() {} catch {}
for (uint256 i = 0; i < reg.erc20s.length; ++i) {
revTraderRewards[i] =
reg.erc20s[i].balanceOf(address(revenueTrader)) -
revTraderRewards[i];
}
}
function nextRecollateralizationAuction(IBackingManager bm, TradeKind kind)
external
returns (
bool canStart,
IERC20 sell,
IERC20 buy,
uint256 sellAmount
)
{
IERC20[] memory erc20s = bm.main().assetRegistry().erc20s();
if (bm.tradesOpen() > 0) {
for (uint256 i = 0; i < erc20s.length; ++i) {
ITrade trade = bm.trades(erc20s[i]);
if (address(trade) != address(0) && trade.canSettle()) {
_settleTrade(bm, erc20s[i]);
break;
}
}
}
if (bm.tradesOpen() == 0) {
_rebalance(bm, kind);
for (uint256 i = 0; i < erc20s.length; ++i) {
ITrade trade = ITrade(address(bm.trades(erc20s[i])));
if (address(trade) != address(0)) {
canStart = true;
sell = trade.sell();
buy = trade.buy();
sellAmount = _getSellAmount(trade);
}
}
}
}
function _getSellAmount(ITrade trade) private view returns (uint256) {
if (trade.KIND() == TradeKind.DUTCH_AUCTION) {
return
DutchTrade(address(trade)).sellAmount().shiftl_toUint(
int8(trade.sell().decimals())
);
} else if (trade.KIND() == TradeKind.BATCH_AUCTION) {
return GnosisTrade(address(trade)).initBal();
} else {
revert("invalid trade type");
}
}
function _settleTrade(ITrading trader, IERC20 toSettle) private {
bytes1 majorVersion = bytes(trader.version())[0];
if (majorVersion == bytes1("3")) {
trader.settleTrade(toSettle);
} else if (majorVersion == bytes1("2") || majorVersion == bytes1("1")) {
address(trader).functionCall(abi.encodeWithSignature("settleTrade(address)", toSettle));
} else {
_revertUnrecognizedVersion();
}
}
function _forwardRevenue(IBackingManager bm, IERC20[] memory toStart) private {
bytes1 majorVersion = bytes(bm.version())[0];
if (majorVersion == bytes1("3")) {
try bm.forwardRevenue(toStart) {} catch {}
} else if (majorVersion == bytes1("2") || majorVersion == bytes1("1")) {
(bool success, ) = address(bm).call{ value: 0 }(
abi.encodeWithSignature("manageTokens(address[])", toStart)
);
success = success;
} else {
_revertUnrecognizedVersion();
}
}
function _runRevenueAuctions(
IRevenueTrader revenueTrader,
IERC20[] memory toStart,
TradeKind[] memory kinds
) private {
bytes1 majorVersion = bytes(revenueTrader.version())[0];
if (majorVersion == bytes1("3")) {
revenueTrader.manageTokens(toStart, kinds);
} else if (majorVersion == bytes1("2") || majorVersion == bytes1("1")) {
for (uint256 i = 0; i < toStart.length; ++i) {
address(revenueTrader).functionCall(
abi.encodeWithSignature("manageToken(address)", toStart[i])
);
}
} else {
_revertUnrecognizedVersion();
}
}
function _rebalance(IBackingManager bm, TradeKind kind) private {
bytes1 majorVersion = bytes(bm.version())[0];
if (majorVersion == bytes1("3")) {
try bm.rebalance(kind) {} catch {}
} else if (majorVersion == bytes1("2") || majorVersion == bytes1("1")) {
IERC20[] memory emptyERC20s = new IERC20[](0);
(bool success, ) = address(bm).call{ value: 0 }(
abi.encodeWithSignature("manageTokens(address[])", emptyERC20s)
);
success = success;
} else {
_revertUnrecognizedVersion();
}
}
function _revertUnrecognizedVersion() private pure {
revert("unrecognized version");
}
}
파일 2 / 41 : Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
require(isContract(target), "Address: delegate call to non-contract");
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
파일 3 / 41 : AddressUpgradeable.sol
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCall(target, data, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value
) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
require(isContract(target), "Address: call to non-contract");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResult(success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
require(isContract(target), "Address: static call to non-contract");
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResult(success, returndata, errorMessage);
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
}
파일 4 / 41 : AggregatorV3Interface.sol
pragma solidity ^0.8.0;
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(uint80 _roundId)
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
function latestRoundData()
external
view
returns (
uint80 roundId,
int256 answer,
uint256 startedAt,
uint256 updatedAt,
uint80 answeredInRound
);
}
파일 5 / 41 : Allowance.sol
pragma solidity 0.8.19;
interface IERC20ApproveOnly {
function approve(address spender, uint256 value) external;
function allowance(address owner, address spender) external view returns (uint256);
}
library AllowanceLib {
function safeApproveFallbackToMax(
address tokenAddress,
address spender,
uint256 value
) internal {
IERC20ApproveOnly token = IERC20ApproveOnly(tokenAddress);
token.approve(spender, 0);
require(token.allowance(address(this), spender) == 0, "allowance not 0");
if (value == 0) return;
bool success;
try token.approve(spender, value) {
success = token.allowance(address(this), spender) == value;
} catch {}
if (!success) {
token.approve(spender, type(uint256).max);
require(token.allowance(address(this), spender) >= value, "allowance missing");
}
}
}
파일 6 / 41 : DutchTrade.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "../../libraries/Fixed.sol";
import "../../libraries/NetworkConfigLib.sol";
import "../../interfaces/IAsset.sol";
import "../../interfaces/IBroker.sol";
import "../../interfaces/ITrade.sol";
interface IDutchTradeCallee {
function dutchTradeCallback(
address buyToken,
uint256 buyAmount,
bytes calldata data
) external;
}
enum BidType {
NONE,
CALLBACK,
TRANSFER
}
uint192 constant FIVE_PERCENT = 5e16;
uint192 constant TWENTY_PERCENT = 20e16;
uint192 constant TWENTY_FIVE_PERCENT = 25e16;
uint192 constant FORTY_FIVE_PERCENT = 45e16;
uint192 constant FIFTY_PERCENT = 50e16;
uint192 constant NINETY_FIVE_PERCENT = 95e16;
uint192 constant MAX_EXP = 6502287e18;
uint192 constant BASE = 999999e12;
uint192 constant ONE_POINT_FIVE = 150e16;
contract DutchTrade is ITrade {
using FixLib for uint192;
using SafeERC20 for IERC20Metadata;
TradeKind public constant KIND = TradeKind.DUTCH_AUCTION;
uint48 public immutable ONE_BLOCK;
BidType public bidType;
TradeStatus public status;
IBroker public broker;
ITrading public origin;
IERC20Metadata public sell;
IERC20Metadata public buy;
uint192 public sellAmount;
uint256 public startBlock;
uint256 public endBlock;
uint48 public endTime;
uint192 public bestPrice;
uint192 public worstPrice;
address public bidder;
modifier stateTransition(TradeStatus begin, TradeStatus end) {
require(status == begin, "Invalid trade state");
status = TradeStatus.PENDING;
_;
assert(status == TradeStatus.PENDING);
status = end;
}
function lot() public view returns (uint256) {
return sellAmount.shiftl_toUint(int8(sell.decimals()));
}
function bidAmount(uint256 blockNumber) external view returns (uint256) {
return _bidAmount(_price(blockNumber));
}
constructor() {
ONE_BLOCK = NetworkConfigLib.blocktime();
status = TradeStatus.CLOSED;
}
function init(
ITrading origin_,
IAsset sell_,
IAsset buy_,
uint256 sellAmount_,
uint48 auctionLength,
TradePrices memory prices
) external stateTransition(TradeStatus.NOT_STARTED, TradeStatus.OPEN) {
assert(
address(sell_) != address(0) &&
address(buy_) != address(0) &&
auctionLength >= 20 * ONE_BLOCK
);
require(prices.sellLow != 0 && prices.sellHigh < FIX_MAX / 1000, "bad sell pricing");
require(prices.buyLow != 0 && prices.buyHigh < FIX_MAX / 1000, "bad buy pricing");
broker = IBroker(msg.sender);
origin = origin_;
sell = sell_.erc20();
buy = buy_.erc20();
require(sellAmount_ <= sell.balanceOf(address(this)), "unfunded trade");
sellAmount = shiftl_toFix(sellAmount_, -int8(sell.decimals()));
uint256 _startBlock = block.number + 1;
startBlock = _startBlock;
uint256 _endBlock = _startBlock + auctionLength / ONE_BLOCK;
endBlock = _endBlock;
endTime = uint48(block.timestamp + ONE_BLOCK * (_endBlock - _startBlock + 1));
uint192 _worstPrice = prices.sellLow.mulDiv(
FIX_ONE - origin.maxTradeSlippage(),
prices.buyHigh,
FLOOR
);
uint192 _bestPrice = prices.sellHigh.div(prices.buyLow, CEIL);
assert(_worstPrice <= _bestPrice);
worstPrice = _worstPrice;
bestPrice = _bestPrice;
}
function bid() external returns (uint256 amountIn) {
require(bidder == address(0), "bid already received");
uint192 price = _price(block.number);
amountIn = _bidAmount(price);
bidder = msg.sender;
bidType = BidType.TRANSFER;
assert(status == TradeStatus.OPEN);
if (price > bestPrice.mul(ONE_POINT_FIVE, CEIL)) {
broker.reportViolation();
}
buy.safeTransferFrom(msg.sender, address(this), amountIn);
origin.settleTrade(sell);
assert(status == TradeStatus.CLOSED);
}
function bidWithCallback(bytes calldata data) external returns (uint256 amountIn) {
require(bidder == address(0), "bid already received");
uint192 price = _price(block.number);
amountIn = _bidAmount(price);
bidder = msg.sender;
bidType = BidType.CALLBACK;
assert(status == TradeStatus.OPEN);
if (price > bestPrice.mul(ONE_POINT_FIVE, CEIL)) {
broker.reportViolation();
}
sell.safeTransfer(bidder, lot());
uint256 balanceBefore = buy.balanceOf(address(this));
IDutchTradeCallee(bidder).dutchTradeCallback(address(buy), amountIn, data);
require(
amountIn <= buy.balanceOf(address(this)) - balanceBefore,
"insufficient buy tokens"
);
origin.settleTrade(sell);
assert(status == TradeStatus.CLOSED);
}
function settle()
external
stateTransition(TradeStatus.OPEN, TradeStatus.CLOSED)
returns (uint256 soldAmt, uint256 boughtAmt)
{
require(msg.sender == address(origin), "only origin can settle");
require(bidder != address(0) || block.number > endBlock, "auction not over");
if (bidType == BidType.CALLBACK) {
soldAmt = lot();
} else if (bidType == BidType.TRANSFER) {
soldAmt = lot();
sell.safeTransfer(bidder, soldAmt);
}
boughtAmt = buy.balanceOf(address(this));
buy.safeTransfer(address(origin), boughtAmt);
sell.safeTransfer(address(origin), sell.balanceOf(address(this)));
}
function transferToOriginAfterTradeComplete(IERC20Metadata erc20) external {
require(status == TradeStatus.CLOSED, "only after trade is closed");
erc20.safeTransfer(address(origin), erc20.balanceOf(address(this)));
}
function canSettle() external view returns (bool) {
return status == TradeStatus.OPEN && (bidder != address(0) || block.number > endBlock);
}
function _price(uint256 blockNumber) private view returns (uint192) {
uint256 _startBlock = startBlock;
uint256 _endBlock = endBlock;
require(blockNumber >= _startBlock, "auction not started");
require(blockNumber <= _endBlock, "auction over");
uint192 progression = divuu(blockNumber - _startBlock, _endBlock - _startBlock);
if (progression < TWENTY_PERCENT) {
uint192 exp = MAX_EXP.mulDiv(TWENTY_PERCENT - progression, TWENTY_PERCENT, ROUND);
return bestPrice.mulDiv(ONE_POINT_FIVE, BASE.powu(uint48(exp.toUint(ROUND))), CEIL);
} else if (progression < FORTY_FIVE_PERCENT) {
uint192 _bestPrice = bestPrice;
uint192 highPrice = _bestPrice.mul(ONE_POINT_FIVE, CEIL);
return
highPrice -
(highPrice - _bestPrice).mulDiv(progression - TWENTY_PERCENT, TWENTY_FIVE_PERCENT);
} else if (progression < NINETY_FIVE_PERCENT) {
uint192 _bestPrice = bestPrice;
return
_bestPrice -
(_bestPrice - worstPrice).mulDiv(progression - FORTY_FIVE_PERCENT, FIFTY_PERCENT);
}
return worstPrice;
}
function _bidAmount(uint192 price) public view returns (uint256) {
return sellAmount.mul(price, CEIL).shiftl_toUint(int8(buy.decimals()), CEIL);
}
}
파일 7 / 41 : Fixed.sol
pragma solidity ^0.8.19;
error UIntOutOfBounds();
bytes32 constant UIntOutofBoundsHash = keccak256(abi.encodeWithSignature("UIntOutOfBounds()"));
uint256 constant FIX_ONE_256 = 1e18;
uint8 constant FIX_DECIMALS = 18;
uint64 constant FIX_SCALE = 1e18;
uint128 constant FIX_SCALE_SQ = 1e36;
uint192 constant FIX_MAX_INT = type(uint192).max / FIX_SCALE;
uint192 constant FIX_ZERO = 0;
uint192 constant FIX_ONE = FIX_SCALE;
uint192 constant FIX_MAX = type(uint192).max;
uint192 constant FIX_MIN = 0;
enum RoundingMode {
FLOOR,
ROUND,
CEIL
}
RoundingMode constant FLOOR = RoundingMode.FLOOR;
RoundingMode constant ROUND = RoundingMode.ROUND;
RoundingMode constant CEIL = RoundingMode.CEIL;
function _safeWrap(uint256 x) pure returns (uint192) {
if (FIX_MAX < x) revert UIntOutOfBounds();
return uint192(x);
}
function toFix(uint256 x) pure returns (uint192) {
return _safeWrap(x * FIX_SCALE);
}
function shiftl_toFix(uint256 x, int8 shiftLeft) pure returns (uint192) {
return shiftl_toFix(x, shiftLeft, FLOOR);
}
function shiftl_toFix(
uint256 x,
int8 shiftLeft,
RoundingMode rounding
) pure returns (uint192) {
if (x == 0) return 0;
if (shiftLeft <= -96) return (rounding == CEIL ? 1 : 0);
if (40 <= shiftLeft) revert UIntOutOfBounds();
shiftLeft += 18;
uint256 coeff = 10**abs(shiftLeft);
uint256 shifted = (shiftLeft >= 0) ? x * coeff : _divrnd(x, coeff, rounding);
return _safeWrap(shifted);
}
function divFix(uint256 x, uint192 y) pure returns (uint192) {
if (x < uint256(type(uint256).max / FIX_SCALE_SQ)) {
return _safeWrap(uint256(x * FIX_SCALE_SQ) / y);
} else {
return _safeWrap(mulDiv256(x, FIX_SCALE_SQ, y));
}
}
function divuu(uint256 x, uint256 y) pure returns (uint192) {
return _safeWrap(mulDiv256(FIX_SCALE, x, y));
}
function fixMin(uint192 x, uint192 y) pure returns (uint192) {
return x < y ? x : y;
}
function fixMax(uint192 x, uint192 y) pure returns (uint192) {
return x > y ? x : y;
}
function abs(int256 x) pure returns (uint256) {
return x < 0 ? uint256(-x) : uint256(x);
}
function _divrnd(
uint256 numerator,
uint256 divisor,
RoundingMode rounding
) pure returns (uint256) {
uint256 result = numerator / divisor;
if (rounding == FLOOR) return result;
if (rounding == ROUND) {
if (numerator % divisor > (divisor - 1) / 2) {
result++;
}
} else {
if (numerator % divisor > 0) {
result++;
}
}
return result;
}
library FixLib {
function toUint(uint192 x) internal pure returns (uint136) {
return toUint(x, FLOOR);
}
function toUint(uint192 x, RoundingMode rounding) internal pure returns (uint136) {
return uint136(_divrnd(uint256(x), FIX_SCALE, rounding));
}
function shiftl(uint192 x, int8 decimals) internal pure returns (uint192) {
return shiftl(x, decimals, FLOOR);
}
function shiftl(
uint192 x,
int8 decimals,
RoundingMode rounding
) internal pure returns (uint192) {
if (x == 0) return 0;
if (decimals <= -59) return (rounding == CEIL ? 1 : 0);
if (58 <= decimals) revert UIntOutOfBounds();
uint256 coeff = uint256(10**abs(decimals));
return _safeWrap(decimals >= 0 ? x * coeff : _divrnd(x, coeff, rounding));
}
function plus(uint192 x, uint192 y) internal pure returns (uint192) {
return x + y;
}
function plusu(uint192 x, uint256 y) internal pure returns (uint192) {
return _safeWrap(x + y * FIX_SCALE);
}
function minus(uint192 x, uint192 y) internal pure returns (uint192) {
return x - y;
}
function minusu(uint192 x, uint256 y) internal pure returns (uint192) {
return _safeWrap(uint256(x) - uint256(y * FIX_SCALE));
}
function mul(uint192 x, uint192 y) internal pure returns (uint192) {
return mul(x, y, ROUND);
}
function mul(
uint192 x,
uint192 y,
RoundingMode rounding
) internal pure returns (uint192) {
return _safeWrap(_divrnd(uint256(x) * uint256(y), FIX_SCALE, rounding));
}
function mulu(uint192 x, uint256 y) internal pure returns (uint192) {
return _safeWrap(x * y);
}
function div(uint192 x, uint192 y) internal pure returns (uint192) {
return div(x, y, FLOOR);
}
function div(
uint192 x,
uint192 y,
RoundingMode rounding
) internal pure returns (uint192) {
return _safeWrap(_divrnd(uint256(x) * FIX_SCALE, y, rounding));
}
function divu(uint192 x, uint256 y) internal pure returns (uint192) {
return divu(x, y, FLOOR);
}
function divu(
uint192 x,
uint256 y,
RoundingMode rounding
) internal pure returns (uint192) {
return _safeWrap(_divrnd(x, y, rounding));
}
uint64 constant FIX_HALF = uint64(FIX_SCALE) / 2;
function powu(uint192 x_, uint48 y) internal pure returns (uint192) {
require(x_ <= FIX_ONE);
if (y == 1) return x_;
if (x_ == FIX_ONE || y == 0) return FIX_ONE;
uint256 x = uint256(x_) * FIX_SCALE;
uint256 result = FIX_SCALE_SQ;
while (true) {
if (y & 1 == 1) result = (result * x + FIX_SCALE_SQ / 2) / FIX_SCALE_SQ;
if (y <= 1) break;
y = (y >> 1);
x = (x * x + FIX_SCALE_SQ / 2) / FIX_SCALE_SQ;
}
return _safeWrap(result / FIX_SCALE);
}
function lt(uint192 x, uint192 y) internal pure returns (bool) {
return x < y;
}
function lte(uint192 x, uint192 y) internal pure returns (bool) {
return x <= y;
}
function gt(uint192 x, uint192 y) internal pure returns (bool) {
return x > y;
}
function gte(uint192 x, uint192 y) internal pure returns (bool) {
return x >= y;
}
function eq(uint192 x, uint192 y) internal pure returns (bool) {
return x == y;
}
function neq(uint192 x, uint192 y) internal pure returns (bool) {
return x != y;
}
function near(
uint192 x,
uint192 y,
uint192 epsilon
) internal pure returns (bool) {
uint192 diff = x <= y ? y - x : x - y;
return diff < epsilon;
}
function shiftl_toUint(uint192 x, int8 decimals) internal pure returns (uint256) {
return shiftl_toUint(x, decimals, FLOOR);
}
function shiftl_toUint(
uint192 x,
int8 decimals,
RoundingMode rounding
) internal pure returns (uint256) {
if (x == 0) return 0;
if (decimals <= -42) return (rounding == CEIL ? 1 : 0);
if (96 <= decimals) revert UIntOutOfBounds();
decimals -= 18;
uint256 coeff = uint256(10**abs(decimals));
return decimals >= 0 ? uint256(x * coeff) : uint256(_divrnd(x, coeff, rounding));
}
function mulu_toUint(uint192 x, uint256 y) internal pure returns (uint256) {
return mulDiv256(uint256(x), y, FIX_SCALE);
}
function mulu_toUint(
uint192 x,
uint256 y,
RoundingMode rounding
) internal pure returns (uint256) {
return mulDiv256(uint256(x), y, FIX_SCALE, rounding);
}
function mul_toUint(uint192 x, uint192 y) internal pure returns (uint256) {
return mulDiv256(uint256(x), uint256(y), FIX_SCALE_SQ);
}
function mul_toUint(
uint192 x,
uint192 y,
RoundingMode rounding
) internal pure returns (uint256) {
return mulDiv256(uint256(x), uint256(y), FIX_SCALE_SQ, rounding);
}
function muluDivu(
uint192 x,
uint256 y,
uint256 z
) internal pure returns (uint192) {
return muluDivu(x, y, z, FLOOR);
}
function muluDivu(
uint192 x,
uint256 y,
uint256 z,
RoundingMode rounding
) internal pure returns (uint192) {
return _safeWrap(mulDiv256(x, y, z, rounding));
}
function mulDiv(
uint192 x,
uint192 y,
uint192 z
) internal pure returns (uint192) {
return mulDiv(x, y, z, FLOOR);
}
function mulDiv(
uint192 x,
uint192 y,
uint192 z,
RoundingMode rounding
) internal pure returns (uint192) {
return _safeWrap(mulDiv256(x, y, z, rounding));
}
function safeMul(
uint192 a,
uint192 b,
RoundingMode rounding
) internal pure returns (uint192) {
if (a == 0 || b == 0) return 0;
if (a == FIX_MAX || b == FIX_MAX) return FIX_MAX;
unchecked {
uint256 rawDelta = uint256(b) * a;
if (rawDelta / b != a) return FIX_MAX;
uint256 shiftDelta = rawDelta;
if (rounding == RoundingMode.ROUND) shiftDelta += (FIX_ONE / 2);
else if (rounding == RoundingMode.CEIL) shiftDelta += FIX_ONE - 1;
if (shiftDelta < rawDelta) return FIX_MAX;
if (shiftDelta / FIX_ONE > FIX_MAX) return FIX_MAX;
return uint192(shiftDelta / FIX_ONE);
}
}
function safeDiv(
uint192 a,
uint192 b,
RoundingMode rounding
) internal pure returns (uint192) {
if (a == 0) return 0;
if (b == 0) return FIX_MAX;
uint256 raw = _divrnd(FIX_ONE_256 * a, uint256(b), rounding);
if (raw >= FIX_MAX) return FIX_MAX;
return uint192(raw);
}
function safeMulDiv(
uint192 a,
uint192 b,
uint192 c,
RoundingMode rounding
) internal pure returns (uint192 result) {
if (a == 0 || b == 0) return 0;
if (a == FIX_MAX || b == FIX_MAX || c == 0) return FIX_MAX;
uint256 result_256;
unchecked {
(uint256 hi, uint256 lo) = fullMul(a, b);
if (hi >= c) return FIX_MAX;
uint256 mm = mulmod(a, b, c);
if (mm > lo) hi -= 1;
lo -= mm;
uint256 pow2 = c & (0 - c);
uint256 c_256 = uint256(c);
c_256 /= pow2;
lo /= pow2;
lo += hi * ((0 - pow2) / pow2 + 1);
uint256 r = 1;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
r *= 2 - c_256 * r;
result_256 = lo * r;
if (rounding == CEIL) {
if (mm > 0) result_256 += 1;
} else if (rounding == ROUND) {
if (mm > ((c_256 - 1) / 2)) result_256 += 1;
}
}
if (result_256 >= FIX_MAX) return FIX_MAX;
return uint192(result_256);
}
}
function mulDiv256(
uint256 x,
uint256 y,
uint256 z
) pure returns (uint256 result) {
unchecked {
(uint256 hi, uint256 lo) = fullMul(x, y);
if (hi >= z) revert UIntOutOfBounds();
uint256 mm = mulmod(x, y, z);
if (mm > lo) hi -= 1;
lo -= mm;
uint256 pow2 = z & (0 - z);
z /= pow2;
lo /= pow2;
lo += hi * ((0 - pow2) / pow2 + 1);
uint256 r = 1;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
r *= 2 - z * r;
result = lo * r;
}
}
function mulDiv256(
uint256 x,
uint256 y,
uint256 z,
RoundingMode rounding
) pure returns (uint256) {
uint256 result = mulDiv256(x, y, z);
if (rounding == FLOOR) return result;
uint256 mm = mulmod(x, y, z);
if (rounding == CEIL) {
if (mm > 0) result += 1;
} else {
if (mm > ((z - 1) / 2)) result += 1;
}
return result;
}
function fullMul(uint256 x, uint256 y) pure returns (uint256 hi, uint256 lo) {
unchecked {
uint256 mm = mulmod(x, y, uint256(0) - uint256(1));
lo = x * y;
hi = mm - lo;
if (mm < lo) hi -= 1;
}
}
파일 8 / 41 : GnosisTrade.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "@openzeppelin/contracts/utils/math/Math.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import "../../libraries/Allowance.sol";
import "../../libraries/Fixed.sol";
import "../../interfaces/IBroker.sol";
import "../../interfaces/IGnosis.sol";
import "../../interfaces/ITrade.sol";
contract GnosisTrade is ITrade {
using FixLib for uint192;
using SafeERC20Upgradeable for IERC20Upgradeable;
TradeKind public constant KIND = TradeKind.BATCH_AUCTION;
uint256 public constant FEE_DENOMINATOR = 1000;
uint96 public constant MAX_ORDERS = 5000;
uint192 public constant DEFAULT_MIN_BID = FIX_ONE / 100;
TradeStatus public status;
IGnosis public gnosis;
uint256 public auctionId;
IBroker public broker;
address public origin;
IERC20Metadata public sell;
IERC20Metadata public buy;
uint256 public initBal;
uint192 public sellAmount;
uint48 public endTime;
uint192 public worstCasePrice;
modifier stateTransition(TradeStatus begin, TradeStatus end) {
require(status == begin, "Invalid trade state");
status = TradeStatus.PENDING;
_;
assert(status == TradeStatus.PENDING);
status = end;
}
constructor() {
status = TradeStatus.CLOSED;
}
function init(
IBroker broker_,
address origin_,
IGnosis gnosis_,
uint48 batchAuctionLength,
TradeRequest calldata req
) external stateTransition(TradeStatus.NOT_STARTED, TradeStatus.OPEN) {
require(req.sellAmount <= type(uint96).max, "sellAmount too large");
require(req.minBuyAmount <= type(uint96).max, "minBuyAmount too large");
sell = req.sell.erc20();
buy = req.buy.erc20();
initBal = sell.balanceOf(address(this));
sellAmount = shiftl_toFix(initBal, -int8(sell.decimals()));
require(initBal <= type(uint96).max, "initBal too large");
require(initBal >= req.sellAmount, "unfunded trade");
assert(origin_ != address(0));
broker = broker_;
origin = origin_;
gnosis = gnosis_;
endTime = uint48(block.timestamp) + batchAuctionLength;
worstCasePrice = shiftl_toFix(req.minBuyAmount, -int8(buy.decimals())).div(
shiftl_toFix(req.sellAmount, -int8(sell.decimals()))
);
uint96 _sellAmount = uint96(
_divrnd(
req.sellAmount * FEE_DENOMINATOR,
FEE_DENOMINATOR + gnosis.feeNumerator(),
FLOOR
)
);
uint96 minBuyAmount = uint96(Math.max(1, req.minBuyAmount));
uint256 minBuyAmtPerOrder = Math.max(
minBuyAmount / MAX_ORDERS,
DEFAULT_MIN_BID.shiftl_toUint(int8(buy.decimals()))
);
if (minBuyAmtPerOrder == 0) minBuyAmtPerOrder = 1;
AllowanceLib.safeApproveFallbackToMax(address(sell), address(gnosis), initBal);
auctionId = gnosis.initiateAuction(
sell,
buy,
endTime,
endTime,
_sellAmount,
minBuyAmount,
minBuyAmtPerOrder,
0,
false,
address(0),
new bytes(0)
);
}
function settle()
external
stateTransition(TradeStatus.OPEN, TradeStatus.CLOSED)
returns (uint256 soldAmt, uint256 boughtAmt)
{
require(msg.sender == origin, "only origin can settle");
if (!isAuctionCleared()) {
gnosis.settleAuction(auctionId);
assert(isAuctionCleared());
}
uint256 sellBal = sell.balanceOf(address(this));
boughtAmt = buy.balanceOf(address(this));
if (sellBal > 0) IERC20Upgradeable(address(sell)).safeTransfer(origin, sellBal);
if (boughtAmt > 0) IERC20Upgradeable(address(buy)).safeTransfer(origin, boughtAmt);
if (sellBal < initBal) {
soldAmt = initBal - sellBal;
uint256 adjustedSoldAmt = Math.max(soldAmt, 1);
uint256 adjustedBuyAmt = boughtAmt + 1;
uint192 clearingPrice = shiftl_toFix(adjustedBuyAmt, -int8(buy.decimals())).div(
shiftl_toFix(adjustedSoldAmt, -int8(sell.decimals()))
);
if (clearingPrice.lt(worstCasePrice)) {
broker.reportViolation();
}
}
}
function transferToOriginAfterTradeComplete(IERC20 erc20) external {
require(status == TradeStatus.CLOSED, "only after trade is closed");
IERC20Upgradeable(address(erc20)).safeTransfer(origin, erc20.balanceOf(address(this)));
}
function canSettle() external view returns (bool) {
return status == TradeStatus.OPEN && endTime <= block.timestamp;
}
function isAuctionCleared() private view returns (bool) {
GnosisAuctionData memory data = gnosis.auctionData(auctionId);
return data.clearingPriceOrder != bytes32(0);
}
}
파일 9 / 41 : IAccessControlUpgradeable.sol
pragma solidity ^0.8.0;
interface IAccessControlUpgradeable {
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address account) external;
}
파일 10 / 41 : IActFacet.sol
pragma solidity 0.8.19;
import "../interfaces/IBackingManager.sol";
import "../interfaces/IStRSRVotes.sol";
import "../interfaces/IRevenueTrader.sol";
import "../interfaces/IRToken.sol";
interface IActFacet {
function claimRewards(IRToken rToken) external;
function runRevenueAuctions(
IRevenueTrader revenueTrader,
IERC20[] memory toSettle,
IERC20[] memory toStart,
TradeKind[] memory kinds
) external;
function revenueOverview(IRevenueTrader revenueTrader)
external
returns (
IERC20[] memory erc20s,
bool[] memory canStart,
uint256[] memory surpluses,
uint256[] memory minTradeAmounts,
uint256[] memory bmRewards,
uint256[] memory revTraderRewards
);
function nextRecollateralizationAuction(IBackingManager bm, TradeKind kind)
external
returns (
bool canStart,
IERC20 sell,
IERC20 buy,
uint256 sellAmount
);
}
파일 11 / 41 : IAsset.sol
pragma solidity 0.8.19;
import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "../libraries/Fixed.sol";
import "./IMain.sol";
import "./IRewardable.sol";
struct Price {
uint192 low;
uint192 high;
}
interface IAsset is IRewardable {
function refresh() external;
function price() external view returns (uint192 low, uint192 high);
function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh);
function bal(address account) external view returns (uint192);
function erc20() external view returns (IERC20Metadata);
function erc20Decimals() external view returns (uint8);
function isCollateral() external view returns (bool);
function maxTradeVolume() external view returns (uint192);
function lastSave() external view returns (uint48);
}
interface TestIAsset is IAsset {
function chainlinkFeed() external view returns (AggregatorV3Interface);
function oracleError() external view returns (uint192);
function oracleTimeout() external view returns (uint48);
function maxOracleTimeout() external view returns (uint48);
function priceTimeout() external view returns (uint48);
function savedLowPrice() external view returns (uint192);
function savedHighPrice() external view returns (uint192);
}
enum CollateralStatus {
SOUND,
IFFY,
DISABLED
}
library CollateralStatusComparator {
function worseThan(CollateralStatus a, CollateralStatus b) internal pure returns (bool) {
return uint256(a) > uint256(b);
}
}
interface ICollateral is IAsset {
event CollateralStatusChanged(
CollateralStatus indexed oldStatus,
CollateralStatus indexed newStatus
);
function targetName() external view returns (bytes32);
function status() external view returns (CollateralStatus);
function refPerTok() external view returns (uint192);
function targetPerRef() external view returns (uint192);
}
interface TestICollateral is TestIAsset, ICollateral {
function whenDefault() external view returns (uint256);
function delayUntilDefault() external view returns (uint48);
function underlyingRefPerTok() external view returns (uint192);
}
파일 12 / 41 : IAssetRegistry.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IAsset.sol";
import "./IComponent.sol";
struct Registry {
IERC20[] erc20s;
IAsset[] assets;
}
interface IAssetRegistry is IComponent {
event AssetRegistered(IERC20 indexed erc20, IAsset indexed asset);
event AssetUnregistered(IERC20 indexed erc20, IAsset indexed asset);
function init(IMain main_, IAsset[] memory assets_) external;
function refresh() external;
function register(IAsset asset) external returns (bool);
function swapRegistered(IAsset asset) external returns (bool swapped);
function unregister(IAsset asset) external;
function lastRefresh() external view returns (uint48);
function toAsset(IERC20 erc20) external view returns (IAsset);
function toColl(IERC20 erc20) external view returns (ICollateral);
function isRegistered(IERC20 erc20) external view returns (bool);
function erc20s() external view returns (IERC20[] memory);
function getRegistry() external view returns (Registry memory reg);
function size() external view returns (uint256);
}
파일 13 / 41 : IBackingManager.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IAssetRegistry.sol";
import "./IBasketHandler.sol";
import "./IBroker.sol";
import "./IComponent.sol";
import "./IRToken.sol";
import "./IStRSR.sol";
import "./ITrading.sol";
struct TradingContext {
BasketRange basketsHeld;
IBasketHandler bh;
IAssetRegistry ar;
IStRSR stRSR;
IERC20 rsr;
IRToken rToken;
uint192 minTradeVolume;
uint192 maxTradeSlippage;
uint192[] quantities;
uint192[] bals;
}
interface IBackingManager is IComponent, ITrading {
event TradingDelaySet(uint48 oldVal, uint48 newVal);
event BackingBufferSet(uint192 oldVal, uint192 newVal);
function init(
IMain main_,
uint48 tradingDelay_,
uint192 backingBuffer_,
uint192 maxTradeSlippage_,
uint192 minTradeVolume_
) external;
function grantRTokenAllowance(IERC20) external;
function rebalance(TradeKind kind) external;
function forwardRevenue(IERC20[] calldata erc20s) external;
function tradingContext(BasketRange memory basketsHeld)
external
view
returns (TradingContext memory ctx, Registry memory reg);
}
interface TestIBackingManager is IBackingManager, TestITrading {
function tradingDelay() external view returns (uint48);
function backingBuffer() external view returns (uint192);
function setTradingDelay(uint48 val) external;
function setBackingBuffer(uint192 val) external;
}
파일 14 / 41 : IBasketHandler.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../libraries/Fixed.sol";
import "./IAsset.sol";
import "./IComponent.sol";
struct BasketRange {
uint192 bottom;
uint192 top;
}
interface IBasketHandler is IComponent {
event PrimeBasketSet(IERC20[] erc20s, uint192[] targetAmts, bytes32[] targetNames);
event BasketSet(uint256 indexed nonce, IERC20[] erc20s, uint192[] refAmts, bool disabled);
event BackupConfigSet(bytes32 indexed targetName, uint256 max, IERC20[] erc20s);
event WarmupPeriodSet(uint48 oldVal, uint48 newVal);
event BasketStatusChanged(CollateralStatus oldStatus, CollateralStatus newStatus);
event LastCollateralizedChanged(uint48 oldVal, uint48 newVal);
function init(
IMain main_,
uint48 warmupPeriod_,
bool reweightable_
) external;
function setPrimeBasket(IERC20[] calldata erc20s, uint192[] calldata targetAmts) external;
function forceSetPrimeBasket(IERC20[] calldata erc20s, uint192[] calldata targetAmts) external;
function setBackupConfig(
bytes32 targetName,
uint256 max,
IERC20[] calldata erc20s
) external;
function disableBasket() external;
function refreshBasket() external;
function trackStatus() external;
function trackCollateralization() external;
function fullyCollateralized() external view returns (bool);
function status() external view returns (CollateralStatus status);
function isReady() external view returns (bool);
function quantity(IERC20 erc20) external view returns (uint192);
function quantityUnsafe(IERC20 erc20, IAsset asset) external view returns (uint192);
function quote(uint192 amount, RoundingMode rounding)
external
view
returns (address[] memory erc20s, uint256[] memory quantities);
function quoteCustomRedemption(
uint48[] memory basketNonces,
uint192[] memory portions,
uint192 amount
) external view returns (address[] memory erc20s, uint256[] memory quantities);
function basketsHeldBy(address account) external view returns (BasketRange memory);
function price() external view returns (uint192 low, uint192 high);
function lotPrice() external view returns (uint192 lotLow, uint192 lotHigh);
function timestamp() external view returns (uint48);
function nonce() external view returns (uint48);
}
interface TestIBasketHandler is IBasketHandler {
function warmupPeriod() external view returns (uint48);
function setWarmupPeriod(uint48 val) external;
}
파일 15 / 41 : IBroker.sol
pragma solidity 0.8.19;
import "./IAsset.sol";
import "./IComponent.sol";
import "./IGnosis.sol";
import "./ITrade.sol";
enum TradeKind {
DUTCH_AUCTION,
BATCH_AUCTION
}
struct TradePrices {
uint192 sellLow;
uint192 sellHigh;
uint192 buyLow;
uint192 buyHigh;
}
struct TradeRequest {
IAsset sell;
IAsset buy;
uint256 sellAmount;
uint256 minBuyAmount;
}
interface IBroker is IComponent {
event GnosisSet(IGnosis oldVal, IGnosis newVal);
event BatchTradeImplementationSet(ITrade oldVal, ITrade newVal);
event DutchTradeImplementationSet(ITrade oldVal, ITrade newVal);
event BatchAuctionLengthSet(uint48 oldVal, uint48 newVal);
event DutchAuctionLengthSet(uint48 oldVal, uint48 newVal);
event BatchTradeDisabledSet(bool prevVal, bool newVal);
event DutchTradeDisabledSet(IERC20Metadata indexed erc20, bool prevVal, bool newVal);
function init(
IMain main_,
IGnosis gnosis_,
ITrade batchTradeImplemention_,
uint48 batchAuctionLength_,
ITrade dutchTradeImplemention_,
uint48 dutchAuctionLength_
) external;
function openTrade(
TradeKind kind,
TradeRequest memory req,
TradePrices memory prices
) external returns (ITrade);
function reportViolation() external;
function batchTradeDisabled() external view returns (bool);
function dutchTradeDisabled(IERC20Metadata erc20) external view returns (bool);
}
interface TestIBroker is IBroker {
function gnosis() external view returns (IGnosis);
function batchTradeImplementation() external view returns (ITrade);
function dutchTradeImplementation() external view returns (ITrade);
function batchAuctionLength() external view returns (uint48);
function dutchAuctionLength() external view returns (uint48);
function setGnosis(IGnosis newGnosis) external;
function setBatchTradeImplementation(ITrade newTradeImplementation) external;
function setBatchAuctionLength(uint48 newAuctionLength) external;
function setDutchTradeImplementation(ITrade newTradeImplementation) external;
function setDutchAuctionLength(uint48 newAuctionLength) external;
function enableBatchTrade() external;
function enableDutchTrade(IERC20Metadata erc20) external;
function disabled() external view returns (bool);
}
파일 16 / 41 : IComponent.sol
pragma solidity 0.8.19;
import "./IMain.sol";
import "./IVersioned.sol";
interface IComponent is IVersioned {
function main() external view returns (IMain);
}
파일 17 / 41 : IDistributor.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IComponent.sol";
uint256 constant MAX_DISTRIBUTION = 1e4;
uint8 constant MAX_DESTINATIONS = 100;
struct RevenueShare {
uint16 rTokenDist;
uint16 rsrDist;
}
struct RevenueTotals {
uint24 rTokenTotal;
uint24 rsrTotal;
}
interface IDistributor is IComponent {
event DistributionSet(address indexed dest, uint16 rTokenDist, uint16 rsrDist);
event RevenueDistributed(IERC20 indexed erc20, address indexed source, uint256 amount);
function init(IMain main_, RevenueShare memory dist) external;
function setDistribution(address dest, RevenueShare memory share) external;
function distribute(IERC20 erc20, uint256 amount) external;
function totals() external view returns (RevenueTotals memory revTotals);
}
interface TestIDistributor is IDistributor {
function FURNACE() external view returns (address);
function ST_RSR() external view returns (address);
function distribution(address) external view returns (uint16 rTokenDist, uint16 rsrDist);
}
파일 18 / 41 : IERC20.sol
pragma solidity ^0.8.0;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
파일 19 / 41 : IERC20Metadata.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
파일 20 / 41 : IERC20MetadataUpgradeable.sol
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
파일 21 / 41 : IERC20Upgradeable.sol
pragma solidity ^0.8.0;
interface IERC20Upgradeable {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool);
}
파일 22 / 41 : IFurnace.sol
pragma solidity 0.8.19;
import "../libraries/Fixed.sol";
import "./IComponent.sol";
interface IFurnace is IComponent {
function init(IMain main_, uint192 ratio_) external;
event RatioSet(uint192 oldRatio, uint192 newRatio);
function ratio() external view returns (uint192);
function setRatio(uint192) external;
function melt() external;
}
interface TestIFurnace is IFurnace {
function lastPayout() external view returns (uint256);
function lastPayoutBal() external view returns (uint256);
}
파일 23 / 41 : IGnosis.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
struct GnosisAuctionData {
IERC20 auctioningToken;
IERC20 biddingToken;
uint256 orderCancellationEndDate;
uint256 auctionEndDate;
bytes32 initialAuctionOrder;
uint256 minimumBiddingAmountPerOrder;
uint256 interimSumBidAmount;
bytes32 interimOrder;
bytes32 clearingPriceOrder;
uint96 volumeClearingPriceOrder;
bool minFundingThresholdNotReached;
bool isAtomicClosureAllowed;
uint256 feeNumerator;
uint256 minFundingThreshold;
}
interface IGnosis {
function initiateAuction(
IERC20 auctioningToken,
IERC20 biddingToken,
uint256 orderCancellationEndDate,
uint256 auctionEndDate,
uint96 auctionedSellAmount,
uint96 minBuyAmount,
uint256 minimumBiddingAmountPerOrder,
uint256 minFundingThreshold,
bool isAtomicClosureAllowed,
address accessManagerContract,
bytes memory accessManagerContractData
) external returns (uint256 auctionId);
function auctionData(uint256 auctionId) external view returns (GnosisAuctionData memory);
function settleAuction(uint256 auctionId) external returns (bytes32 encodedOrder);
function feeNumerator() external returns (uint256);
}
파일 24 / 41 : IMain.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts-upgradeable/access/IAccessControlUpgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IAssetRegistry.sol";
import "./IBasketHandler.sol";
import "./IBackingManager.sol";
import "./IBroker.sol";
import "./IGnosis.sol";
import "./IFurnace.sol";
import "./IDistributor.sol";
import "./IRToken.sol";
import "./IRevenueTrader.sol";
import "./IStRSR.sol";
import "./ITrading.sol";
import "./IVersioned.sol";
bytes32 constant OWNER = bytes32(bytes("OWNER"));
bytes32 constant SHORT_FREEZER = bytes32(bytes("SHORT_FREEZER"));
bytes32 constant LONG_FREEZER = bytes32(bytes("LONG_FREEZER"));
bytes32 constant PAUSER = bytes32(bytes("PAUSER"));
struct Components {
IRToken rToken;
IStRSR stRSR;
IAssetRegistry assetRegistry;
IBasketHandler basketHandler;
IBackingManager backingManager;
IDistributor distributor;
IFurnace furnace;
IBroker broker;
IRevenueTrader rsrTrader;
IRevenueTrader rTokenTrader;
}
interface IAuth is IAccessControlUpgradeable {
event UnfreezeAtSet(uint48 oldVal, uint48 newVal);
event ShortFreezeDurationSet(uint48 oldDuration, uint48 newDuration);
event LongFreezeDurationSet(uint48 oldDuration, uint48 newDuration);
event TradingPausedSet(bool oldVal, bool newVal);
event IssuancePausedSet(bool oldVal, bool newVal);
function tradingPausedOrFrozen() external view returns (bool);
function issuancePausedOrFrozen() external view returns (bool);
function frozen() external view returns (bool);
function shortFreeze() external view returns (uint48);
function longFreeze() external view returns (uint48);
function freezeForever() external;
function freezeShort() external;
function freezeLong() external;
function unfreeze() external;
function pauseTrading() external;
function unpauseTrading() external;
function pauseIssuance() external;
function unpauseIssuance() external;
}
interface IComponentRegistry {
event RTokenSet(IRToken indexed oldVal, IRToken indexed newVal);
function rToken() external view returns (IRToken);
event StRSRSet(IStRSR oldVal, IStRSR newVal);
function stRSR() external view returns (IStRSR);
event AssetRegistrySet(IAssetRegistry oldVal, IAssetRegistry newVal);
function assetRegistry() external view returns (IAssetRegistry);
event BasketHandlerSet(IBasketHandler oldVal, IBasketHandler newVal);
function basketHandler() external view returns (IBasketHandler);
event BackingManagerSet(IBackingManager oldVal, IBackingManager newVal);
function backingManager() external view returns (IBackingManager);
event DistributorSet(IDistributor oldVal, IDistributor newVal);
function distributor() external view returns (IDistributor);
event RSRTraderSet(IRevenueTrader oldVal, IRevenueTrader newVal);
function rsrTrader() external view returns (IRevenueTrader);
event RTokenTraderSet(IRevenueTrader oldVal, IRevenueTrader newVal);
function rTokenTrader() external view returns (IRevenueTrader);
event FurnaceSet(IFurnace oldVal, IFurnace newVal);
function furnace() external view returns (IFurnace);
event BrokerSet(IBroker oldVal, IBroker newVal);
function broker() external view returns (IBroker);
}
interface IMain is IVersioned, IAuth, IComponentRegistry {
function poke() external;
event MainInitialized();
function init(
Components memory components,
IERC20 rsr_,
uint48 shortFreeze_,
uint48 longFreeze_
) external;
function rsr() external view returns (IERC20);
}
interface TestIMain is IMain {
function setShortFreeze(uint48) external;
function setLongFreeze(uint48) external;
function shortFreeze() external view returns (uint48);
function longFreeze() external view returns (uint48);
function longFreezes(address account) external view returns (uint256);
function tradingPaused() external view returns (bool);
function issuancePaused() external view returns (bool);
}
파일 25 / 41 : IRToken.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol";
import "../libraries/Fixed.sol";
import "../libraries/Throttle.sol";
import "./IAsset.sol";
import "./IComponent.sol";
import "./IMain.sol";
import "./IRewardable.sol";
interface IRToken is IComponent, IERC20MetadataUpgradeable, IERC20PermitUpgradeable {
event Issuance(
address indexed issuer,
address indexed recipient,
uint256 amount,
uint192 baskets
);
event Redemption(
address indexed redeemer,
address indexed recipient,
uint256 amount,
uint192 baskets
);
event BasketsNeededChanged(uint192 oldBasketsNeeded, uint192 newBasketsNeeded);
event Melted(uint256 amount);
event IssuanceThrottleSet(ThrottleLib.Params oldVal, ThrottleLib.Params newVal);
event RedemptionThrottleSet(ThrottleLib.Params oldVal, ThrottleLib.Params newVal);
function init(
IMain main_,
string memory name_,
string memory symbol_,
string memory mandate_,
ThrottleLib.Params calldata issuanceThrottleParams,
ThrottleLib.Params calldata redemptionThrottleParams
) external;
function issue(uint256 amount) external;
function issueTo(address recipient, uint256 amount) external;
function redeem(uint256 amount) external;
function redeemTo(address recipient, uint256 amount) external;
function redeemCustom(
address recipient,
uint256 amount,
uint48[] memory basketNonces,
uint192[] memory portions,
address[] memory expectedERC20sOut,
uint256[] memory minAmounts
) external;
function mint(uint192 baskets) external;
function melt(uint256 amount) external;
function dissolve(uint256 amount) external;
function setBasketsNeeded(uint192 basketsNeeded) external;
function basketsNeeded() external view returns (uint192);
function issuanceAvailable() external view returns (uint256);
function redemptionAvailable() external view returns (uint256);
}
interface TestIRToken is IRToken {
function setIssuanceThrottleParams(ThrottleLib.Params calldata) external;
function setRedemptionThrottleParams(ThrottleLib.Params calldata) external;
function issuanceThrottleParams() external view returns (ThrottleLib.Params memory);
function redemptionThrottleParams() external view returns (ThrottleLib.Params memory);
function increaseAllowance(address, uint256) external returns (bool);
function decreaseAllowance(address, uint256) external returns (bool);
function monetizeDonations(IERC20) external;
}
파일 26 / 41 : IRevenueTrader.sol
pragma solidity 0.8.19;
import "./IBroker.sol";
import "./IComponent.sol";
import "./ITrading.sol";
interface IRevenueTrader is IComponent, ITrading {
function init(
IMain main_,
IERC20 tokenToBuy_,
uint192 maxTradeSlippage_,
uint192 minTradeVolume_
) external;
function distributeTokenToBuy() external;
function returnTokens(IERC20[] memory erc20s) external;
function manageTokens(IERC20[] memory erc20s, TradeKind[] memory kinds) external;
function tokenToBuy() external view returns (IERC20);
}
interface TestIRevenueTrader is IRevenueTrader, TestITrading {
}
파일 27 / 41 : IRewardable.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "./IComponent.sol";
import "./IMain.sol";
interface IRewardable {
event RewardsClaimed(IERC20 indexed erc20, uint256 amount);
function claimRewards() external;
}
interface IRewardableComponent is IRewardable {
function claimRewardsSingle(IERC20 erc20) external;
}
파일 28 / 41 : IStRSR.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/IERC20MetadataUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/draft-IERC20PermitUpgradeable.sol";
import "../libraries/Fixed.sol";
import "./IComponent.sol";
import "./IMain.sol";
interface IStRSR is IERC20MetadataUpgradeable, IERC20PermitUpgradeable, IComponent {
event Staked(
uint256 indexed era,
address indexed staker,
uint256 rsrAmount,
uint256 stRSRAmount
);
event UnstakingStarted(
uint256 indexed draftId,
uint256 indexed draftEra,
address indexed staker,
uint256 rsrAmount,
uint256 stRSRAmount,
uint256 availableAt
);
event UnstakingCompleted(
uint256 indexed firstId,
uint256 indexed endId,
uint256 draftEra,
address indexed staker,
uint256 rsrAmount
);
event UnstakingCancelled(
uint256 indexed firstId,
uint256 indexed endId,
uint256 draftEra,
address indexed staker,
uint256 rsrAmount
);
event ExchangeRateSet(uint192 oldVal, uint192 newVal);
event RewardsPaid(uint256 rsrAmt);
event AllBalancesReset(uint256 indexed newEra);
event AllUnstakingReset(uint256 indexed newEra);
event UnstakingDelaySet(uint48 oldVal, uint48 newVal);
event RewardRatioSet(uint192 oldVal, uint192 newVal);
event WithdrawalLeakSet(uint192 oldVal, uint192 newVal);
function init(
IMain main_,
string memory name_,
string memory symbol_,
uint48 unstakingDelay_,
uint192 rewardRatio_,
uint192 withdrawalLeak_
) external;
function payoutRewards() external;
function stake(uint256 amount) external;
function unstake(uint256 amount) external;
function withdraw(address account, uint256 endId) external;
function cancelUnstake(uint256 endId) external;
function seizeRSR(uint256 amount) external;
function resetStakes() external;
function endIdForWithdraw(address account) external view returns (uint256 endId);
function exchangeRate() external view returns (uint192);
}
interface TestIStRSR is IStRSR {
function rewardRatio() external view returns (uint192);
function setRewardRatio(uint192) external;
function unstakingDelay() external view returns (uint48);
function setUnstakingDelay(uint48) external;
function withdrawalLeak() external view returns (uint192);
function setWithdrawalLeak(uint192) external;
function increaseAllowance(address, uint256) external returns (bool);
function decreaseAllowance(address, uint256) external returns (bool);
function exchangeRate() external view returns (uint192);
}
파일 29 / 41 : IStRSRVotes.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts-upgradeable/governance/utils/IVotesUpgradeable.sol";
interface IStRSRVotes is IVotesUpgradeable {
function currentEra() external view returns (uint256);
function getPastEra(uint256 blockNumber) external view returns (uint256);
function stakeAndDelegate(uint256 amount, address delegatee) external;
}
파일 30 / 41 : ITrade.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol";
import "./IBroker.sol";
enum TradeStatus {
NOT_STARTED,
OPEN,
CLOSED,
PENDING
}
interface ITrade {
function settle() external returns (uint256 soldAmt, uint256 boughtAmt);
function sell() external view returns (IERC20Metadata);
function buy() external view returns (IERC20Metadata);
function sellAmount() external view returns (uint192);
function endTime() external view returns (uint48);
function canSettle() external view returns (bool);
function KIND() external view returns (TradeKind);
}
파일 31 / 41 : ITrading.sol
pragma solidity 0.8.19;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../libraries/Fixed.sol";
import "./IAsset.sol";
import "./IComponent.sol";
import "./ITrade.sol";
import "./IRewardable.sol";
interface ITrading is IComponent, IRewardableComponent {
event MaxTradeSlippageSet(uint192 oldVal, uint192 newVal);
event MinTradeVolumeSet(uint192 oldVal, uint192 newVal);
event TradeStarted(
ITrade indexed trade,
IERC20 indexed sell,
IERC20 indexed buy,
uint256 sellAmount,
uint256 minBuyAmount
);
event TradeSettled(
ITrade indexed trade,
IERC20 indexed sell,
IERC20 indexed buy,
uint256 sellAmount,
uint256 buyAmount
);
function settleTrade(IERC20 sell) external returns (ITrade);
function maxTradeSlippage() external view returns (uint192);
function minTradeVolume() external view returns (uint192);
function trades(IERC20 sell) external view returns (ITrade);
function tradesOpen() external view returns (uint48);
function tradesNonce() external view returns (uint256);
}
interface TestITrading is ITrading {
function setMaxTradeSlippage(uint192 val) external;
function setMinTradeVolume(uint192 val) external;
}
파일 32 / 41 : IVersioned.sol
pragma solidity 0.8.19;
interface IVersioned {
function version() external view returns (string memory);
}
파일 33 / 41 : IVotesUpgradeable.sol
pragma solidity ^0.8.0;
interface IVotesUpgradeable {
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);
function getVotes(address account) external view returns (uint256);
function getPastVotes(address account, uint256 blockNumber) external view returns (uint256);
function getPastTotalSupply(uint256 blockNumber) external view returns (uint256);
function delegates(address account) external view returns (address);
function delegate(address delegatee) external;
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) external;
}
파일 34 / 41 : Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1);
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1;
uint256 x = a;
if (x >> 128 > 0) {
x >>= 128;
result <<= 64;
}
if (x >> 64 > 0) {
x >>= 64;
result <<= 32;
}
if (x >> 32 > 0) {
x >>= 32;
result <<= 16;
}
if (x >> 16 > 0) {
x >>= 16;
result <<= 8;
}
if (x >> 8 > 0) {
x >>= 8;
result <<= 4;
}
if (x >> 4 > 0) {
x >>= 4;
result <<= 2;
}
if (x >> 2 > 0) {
result <<= 1;
}
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
uint256 result = sqrt(a);
if (rounding == Rounding.Up && result * result < a) {
result += 1;
}
return result;
}
}
파일 35 / 41 : Multicall.sol
pragma solidity ^0.8.0;
import "./Address.sol";
abstract contract Multicall {
function multicall(bytes[] calldata data) external virtual returns (bytes[] memory results) {
results = new bytes[](data.length);
for (uint256 i = 0; i < data.length; i++) {
results[i] = Address.functionDelegateCall(address(this), data[i]);
}
return results;
}
}
파일 36 / 41 : NetworkConfigLib.sol
pragma solidity 0.8.19;
library NetworkConfigLib {
error InvalidNetwork();
function blocktime() internal view returns (uint48) {
uint256 chainId = block.chainid;
if (chainId == 1 || chainId == 3 || chainId == 5 || chainId == 31337) {
return 12;
} else if (chainId == 8453 || chainId == 84531) {
return 2;
} else {
revert InvalidNetwork();
}
}
}
파일 37 / 41 : SafeERC20.sol
pragma solidity ^0.8.0;
import "../IERC20.sol";
import "../extensions/draft-IERC20Permit.sol";
import "../../../utils/Address.sol";
library SafeERC20 {
using Address for address;
function safeTransfer(
IERC20 token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20 token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20 token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20 token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
파일 38 / 41 : SafeERC20Upgradeable.sol
pragma solidity ^0.8.0;
import "../IERC20Upgradeable.sol";
import "../extensions/draft-IERC20PermitUpgradeable.sol";
import "../../../utils/AddressUpgradeable.sol";
library SafeERC20Upgradeable {
using AddressUpgradeable for address;
function safeTransfer(
IERC20Upgradeable token,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(
IERC20Upgradeable token,
address from,
address to,
uint256 value
) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(
IERC20Upgradeable token,
address spender,
uint256 value
) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(
IERC20Upgradeable token,
address spender,
uint256 value
) internal {
uint256 newAllowance = token.allowance(address(this), spender) + value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
function safeDecreaseAllowance(
IERC20Upgradeable token,
address spender,
uint256 value
) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
uint256 newAllowance = oldAllowance - value;
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
}
}
function safePermit(
IERC20PermitUpgradeable token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
if (returndata.length > 0) {
require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
}
}
파일 39 / 41 : Throttle.sol
pragma solidity 0.8.19;
import "./Fixed.sol";
uint48 constant ONE_HOUR = 3600;
library ThrottleLib {
using FixLib for uint192;
struct Params {
uint256 amtRate;
uint192 pctRate;
}
struct Throttle {
Params params;
uint48 lastTimestamp;
uint256 lastAvailable;
}
function useAvailable(
Throttle storage throttle,
uint256 supply,
int256 amount
) internal {
if (throttle.params.amtRate == 0 && throttle.params.pctRate == 0) return;
uint256 limit = hourlyLimit(throttle, supply);
uint256 available = currentlyAvailable(throttle, limit);
if (available != throttle.lastAvailable || available == limit) {
throttle.lastTimestamp = uint48(block.timestamp);
}
if (amount > 0) {
require(uint256(amount) <= available, "supply change throttled");
available -= uint256(amount);
} else if (amount < 0) {
available += uint256(-amount);
}
throttle.lastAvailable = available;
}
function currentlyAvailable(Throttle storage throttle, uint256 limit)
internal
view
returns (uint256 available)
{
uint48 delta = uint48(block.timestamp) - throttle.lastTimestamp;
available = throttle.lastAvailable + (limit * delta) / ONE_HOUR;
if (available > limit) available = limit;
}
function hourlyLimit(Throttle storage throttle, uint256 supply)
internal
view
returns (uint256 limit)
{
Params storage params = throttle.params;
limit = (supply * params.pctRate) / FIX_ONE_256;
if (params.amtRate > limit) limit = params.amtRate;
}
}
파일 40 / 41 : draft-IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
파일 41 / 41 : draft-IERC20PermitUpgradeable.sol
pragma solidity ^0.8.0;
interface IERC20PermitUpgradeable {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
{
"compilationTarget": {
"contracts/facade/facets/ActFacet.sol": "ActFacet"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": []
}[{"inputs":[],"name":"UIntOutOfBounds","type":"error"},{"inputs":[{"internalType":"contract IRToken","name":"rToken","type":"address"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"data","type":"bytes[]"}],"name":"multicall","outputs":[{"internalType":"bytes[]","name":"results","type":"bytes[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IBackingManager","name":"bm","type":"address"},{"internalType":"enum TradeKind","name":"kind","type":"uint8"}],"name":"nextRecollateralizationAuction","outputs":[{"internalType":"bool","name":"canStart","type":"bool"},{"internalType":"contract IERC20","name":"sell","type":"address"},{"internalType":"contract IERC20","name":"buy","type":"address"},{"internalType":"uint256","name":"sellAmount","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IRevenueTrader","name":"revenueTrader","type":"address"}],"name":"revenueOverview","outputs":[{"internalType":"contract IERC20[]","name":"erc20s","type":"address[]"},{"internalType":"bool[]","name":"canStart","type":"bool[]"},{"internalType":"uint256[]","name":"surpluses","type":"uint256[]"},{"internalType":"uint256[]","name":"minTradeAmounts","type":"uint256[]"},{"internalType":"uint256[]","name":"bmRewards","type":"uint256[]"},{"internalType":"uint256[]","name":"revTraderRewards","type":"uint256[]"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IRevenueTrader","name":"revenueTrader","type":"address"},{"internalType":"contract IERC20[]","name":"toSettle","type":"address[]"},{"internalType":"contract IERC20[]","name":"toStart","type":"address[]"},{"internalType":"enum TradeKind[]","name":"kinds","type":"uint8[]"}],"name":"runRevenueAuctions","outputs":[],"stateMutability":"nonpayable","type":"function"}]
