Pool Together 3.0

1abstract contract PrizePool is PrizePoolInterface, OwnableUpgradeable, ReentrancyGuardUpgradeable, TokenControllerInterface, IERC721ReceiverUpgradeable {
2  using SafeMathUpgradeable for uint256;
3  using SafeCastUpgradeable for uint256;
4  using SafeERC20Upgradeable for IERC20Upgradeable;
5  using SafeERC20Upgradeable for IERC721Upgradeable;
6  using MappedSinglyLinkedList for MappedSinglyLinkedList.Mapping;
7  using ERC165CheckerUpgradeable for address;
8​
9  /// @dev Emitted when an instance is initialized
10  event Initialized(
11    address reserveRegistry,
12    uint256 maxExitFeeMantissa
13  );
14​
15  /// @dev Event emitted when controlled token is added
16  event ControlledTokenAdded(
17    ControlledTokenInterface indexed token
18  );
19​
20  /// @dev Emitted when reserve is captured.
21  event ReserveFeeCaptured(
22    uint256 amount
23  );
24​
25  event AwardCaptured(
26    uint256 amount
27  );
28​
29  /// @dev Event emitted when assets are deposited
30  event Deposited(
31    address indexed operator,
32    address indexed to,
33    address indexed token,
34    uint256 amount,
35    address referrer
36  );
37​
38  /// @dev Event emitted when interest is awarded to a winner
39  event Awarded(
40    address indexed winner,
41    address indexed token,
42    uint256 amount
43  );
44​
45  /// @dev Event emitted when external ERC20s are awarded to a winner
46  event AwardedExternalERC20(
47    address indexed winner,
48    address indexed token,
49    uint256 amount
50  );
51​
52  /// @dev Event emitted when external ERC20s are transferred out
53  event TransferredExternalERC20(
54    address indexed to,
55    address indexed token,
56    uint256 amount
57  );
58​
59  /// @dev Event emitted when external ERC721s are awarded to a winner
60  event AwardedExternalERC721(
61    address indexed winner,
62    address indexed token,
63    uint256[] tokenIds
64  );
65​
66  /// @dev Event emitted when assets are withdrawn instantly
67  event InstantWithdrawal(
68    address indexed operator,
69    address indexed from,
70    address indexed token,
71    uint256 amount,
72    uint256 redeemed,
73    uint256 exitFee
74  );
75​
76  event ReserveWithdrawal(
77    address indexed to,
78    uint256 amount
79  );
80​
81  /// @dev Event emitted when the Liquidity Cap is set
82  event LiquidityCapSet(
83    uint256 liquidityCap
84  );
85​
86  /// @dev Event emitted when the Credit plan is set
87  event CreditPlanSet(
88    address token,
89    uint128 creditLimitMantissa,
90    uint128 creditRateMantissa
91  );
92​
93  /// @dev Event emitted when the Prize Strategy is set
94  event PrizeStrategySet(
95    address indexed prizeStrategy
96  );
97​
98  /// @dev Emitted when credit is minted
99  event CreditMinted(
100    address indexed user,
101    address indexed token,
102    uint256 amount
103  );
104​
105  /// @dev Emitted when credit is burned
106  event CreditBurned(
107    address indexed user,
108    address indexed token,
109    uint256 amount
110  );
111​
112  /// @dev Emitted when there was an error thrown awarding an External ERC721
113  event ErrorAwardingExternalERC721(bytes error);
114​
115​
116  struct CreditPlan {
117    uint128 creditLimitMantissa;
118    uint128 creditRateMantissa;
119  }
120​
121  struct CreditBalance {
122    uint192 balance;
123    uint32 timestamp;
124    bool initialized;
125  }
126​
127  /// @notice Semver Version
128  string constant public VERSION = "3.4.5";
129​
130  /// @dev Reserve to which reserve fees are sent
131  RegistryInterface public reserveRegistry;
132​
133  /// @dev An array of all the controlled tokens
134  ControlledTokenInterface[] internal _tokens;
135​
136  /// @dev The Prize Strategy that this Prize Pool is bound to.
137  TokenListenerInterface public prizeStrategy;
138​
139  /// @dev The maximum possible exit fee fraction as a fixed point 18 number.
140  /// For example, if the maxExitFeeMantissa is "0.1 ether", then the maximum exit fee for a withdrawal of 100 Dai will be 10 Dai
141  uint256 public maxExitFeeMantissa;
142​
143  /// @dev The total funds that have been allocated to the reserve
144  uint256 public reserveTotalSupply;
145​
146  /// @dev The total amount of funds that the prize pool can hold.
147  uint256 public liquidityCap;
148​
149  /// @dev the The awardable balance
150  uint256 internal _currentAwardBalance;
151​
152  /// @dev Stores the credit plan for each token.
153  mapping(address => CreditPlan) internal _tokenCreditPlans;
154​
155  /// @dev Stores each users balance of credit per token.
156  mapping(address => mapping(address => CreditBalance)) internal _tokenCreditBalances;
157​
158  /// @notice Initializes the Prize Pool
159  // @param _controlledTokens Array of ControlledTokens that are controlled by this Prize Pool.
160  // @param _maxExitFeeMantissa The maximum exit fee size
161  function initialize (
162    RegistryInterface _reserveRegistry,
163    ControlledTokenInterface[] memory _controlledTokens,
164    uint256 _maxExitFeeMantissa
165  )
166    public
167    initializer
168  {
169    require(address(_reserveRegistry) != address(0), "PrizePool/reserveRegistry-not-zero");
170    uint256 controlledTokensLength = _controlledTokens.length;
171    _tokens = new ControlledTokenInterface[](controlledTokensLength);
172​
173    for (uint256 i = 0; i < controlledTokensLength; i++) {
174      ControlledTokenInterface controlledToken = _controlledTokens[i];
175      _addControlledToken(controlledToken, i);
176    }
177    __Ownable_init();
178    __ReentrancyGuard_init();
179    _setLiquidityCap(uint256(-1));
180​
181    reserveRegistry = _reserveRegistry;
182    maxExitFeeMantissa = _maxExitFeeMantissa;
183​
184    emit Initialized(
185      address(_reserveRegistry),
186      maxExitFeeMantissa
187    );
188  }

Solidity Contracts

JavaScript Tests