| 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 |
132×
132×
132×
12×
12×
12×
12×
12×
12×
12×
204×
1×
275×
275×
275×
275×
275×
239×
239×
239×
138×
137×
137×
192×
191×
191×
824×
| // SPDX-License-Identifier: BlueOak-1.0.0
pragma solidity 0.8.17;
import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/utils/SafeERC20Upgradeable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Multicall.sol";
import "../../interfaces/ITrade.sol";
import "../../interfaces/ITrading.sol";
import "../../libraries/Fixed.sol";
import "./Component.sol";
import "./RewardableLib.sol";
/// Abstract trading mixin for all Traders, to be paired with TradingLib
/// @dev See docs/security for discussion of Multicall safety
abstract contract TradingP1 is Multicall, ComponentP1, ReentrancyGuardUpgradeable, ITrading {
using FixLib for uint192;
using SafeERC20Upgradeable for IERC20Upgradeable;
uint192 public constant MAX_TRADE_VOLUME = 1e29; // {UoA}
uint192 public constant MAX_TRADE_SLIPPAGE = 1e18; // {%}
// Peer contracts, immutable after init()
IBroker private broker;
// All open trades
mapping(IERC20 => ITrade) public trades;
uint48 public tradesOpen;
// === Governance param ===
uint192 public maxTradeSlippage; // {%}
uint192 public minTradeVolume; // {UoA}
// ==== Invariants ====
// tradesOpen = len(values(trades))
// trades[sell] != 0 iff trade[sell] has been opened and not yet settled
// untestable:
// `else` branch of `onlyInitializing` (ie. revert) is currently untestable.
// This function is only called inside other `init` functions, each of which is wrapped
// in an `initializer` modifier, which would fail first.
// solhint-disable-next-line func-name-mixedcase
function __Trading_init(
IMain main_,
uint192 maxTradeSlippage_,
uint192 minTradeVolume_
) internal EonlyInitializing {
broker = main_.broker();
setMaxTradeSlippage(maxTradeSlippage_);
setMinTradeVolume(minTradeVolume_);
}
/// Settle a single trade, expected to be used with multicall for efficient mass settlement
/// @custom:interaction (only reads or writes trades, and is marked `nonReentrant`)
// checks:
// !paused, !frozen
// trade[sell].canSettle()
// actions:
// trade[sell].settle()
// effects:
// trades.set(sell, 0)
// tradesOpen' = tradesOpen - 1
// untested:
// OZ nonReentrant line is assumed to be working. cost/benefit of direct testing is high
function settleTrade(IERC20 sell) external notPausedOrFrozen EnonReentrant {
ITrade trade = trades[sell];
Iif (address(trade) == address(0)) return;
Erequire(trade.canSettle(), "cannot settle yet");
delete trades[sell];
tradesOpen--;
// == Interactions ==
(uint256 soldAmt, uint256 boughtAmt) = trade.settle();
emit TradeSettled(trade, trade.sell(), trade.buy(), soldAmt, boughtAmt);
}
/// Claim all rewards
/// Collective Action
/// @custom:interaction CEI
function claimRewards() external notPausedOrFrozen {
RewardableLibP1.claimRewards(main.assetRegistry());
}
/// Claim rewards for a single asset
/// Collective Action
/// @param erc20 The ERC20 to claimRewards on
/// @custom:interaction CEI
function claimRewardsSingle(IERC20 erc20) external notPausedOrFrozen {
RewardableLibP1.claimRewardsSingle(main.assetRegistry().toAsset(erc20));
}
/// Try to initiate a trade with a trading partner provided by the broker
/// @custom:interaction (only reads or writes `trades`, and is marked `nonReentrant`)
// checks:
// (not external, so we don't need auth or pause checks)
// trades[req.sell] == 0
// actions:
// req.sell.increaseAllowance(broker, req.sellAmount) - two safeApprove calls to support USDT
// tradeID = broker.openTrade(req)
// effects:
// trades' = trades.set(req.sell, tradeID)
// tradesOpen' = tradesOpen + 1
//
// untested:
// OZ nonReentrant line is assumed to be working. cost/benefit of direct testing is high
// This is reentrancy-safe because we're using the `nonReentrant` modifier on every method of
// this contract that changes state this function refers to.
// slither-disable-next-line reentrancy-vulnerabilities-1
function tryTrade(TradeRequest memory req) internal EnonReentrant {
/* */
IERC20 sell = req.sell.erc20();
assert(address(trades[sell]) == address(0));
IERC20Upgradeable(address(sell)).safeApprove(address(broker), 0);
IERC20Upgradeable(address(sell)).safeApprove(address(broker), req.sellAmount);
ITrade trade = broker.openTrade(req);
trades[sell] = trade;
tradesOpen++;
emit TradeStarted(trade, sell, req.buy.erc20(), req.sellAmount, req.minBuyAmount);
}
// === Setters ===
/// @custom:governance
function setMaxTradeSlippage(uint192 val) public governance {
require(val < MAX_TRADE_SLIPPAGE, "invalid maxTradeSlippage");
emit MaxTradeSlippageSet(maxTradeSlippage, val);
maxTradeSlippage = val;
}
/// @custom:governance
function setMinTradeVolume(uint192 val) public governance {
require(val <= MAX_TRADE_VOLUME, "invalid minTradeVolume");
emit MinTradeVolumeSet(minTradeVolume, val);
minTradeVolume = val;
}
// === FixLib Helper ===
/// Light wrapper around FixLib.mulDiv to support try-catch
function mulDivCeil(
uint192 x,
uint192 y,
uint192 z
) external pure returns (uint192) {
return x.mulDiv(y, z, CEIL);
}
/**
* @dev This empty reserved space is put in place to allow future versions to add new
* variables without shifting down storage in the inheritance chain.
* See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
*/
uint256[46] private __gap;
}
|