PoolTogether v4

1
2import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
3import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
4import "@openzeppelin/contracts/utils/Address.sol";
5import "@pooltogether/yield-source-interface/contracts/IYieldSource.sol";
6
7import "./PrizePool.sol";
8
9/**
10 * @title  PoolTogether V4 YieldSourcePrizePool
11 * @author PoolTogether Inc Team
12 * @notice The Yield Source Prize Pool uses a yield source contract to generate prizes.
13 *         Funds that are deposited into the prize pool are then deposited into a yield source. (i.e. Aave, Compound, etc...)
14 */
15contract YieldSourcePrizePool is PrizePool {
16    using SafeERC20 for IERC20;
17    using Address for address;
18
19    /// @notice Address of the yield source.
20    IYieldSource public immutable yieldSource;
21
22    /// @dev Emitted when yield source prize pool is deployed.
23    /// @param yieldSource Address of the yield source.
24    event Deployed(address indexed yieldSource);
25
26    /// @notice Emitted when stray deposit token balance in this contract is swept
27    /// @param amount The amount that was swept
28    event Swept(uint256 amount);
29
30    /// @notice Deploy the Prize Pool and Yield Service with the required contract connections
31    /// @param _owner Address of the Yield Source Prize Pool owner
32    /// @param _yieldSource Address of the yield source
33    constructor(address _owner, IYieldSource _yieldSource) PrizePool(_owner) {
34        require(
35            address(_yieldSource) != address(0),
36            "YieldSourcePrizePool/yield-source-not-zero-address"
37        );
38
39        yieldSource = _yieldSource;
40
41        // A hack to determine whether it's an actual yield source
42        (bool succeeded, bytes memory data) = address(_yieldSource).staticcall(
43            abi.encodePacked(_yieldSource.depositToken.selector)
44        );
45        address resultingAddress;
46        if (data.length > 0) {
47            resultingAddress = abi.decode(data, (address));
48        }
49        require(succeeded && resultingAddress != address(0), "YieldSourcePrizePool/invalid-yield-source");
50
51        emit Deployed(address(_yieldSource));
52    }
53
54    /// @notice Sweeps any stray balance of deposit tokens into the yield source.
55    /// @dev This becomes prize money
56    function sweep() external nonReentrant onlyOwner {
57        uint256 balance = _token().balanceOf(address(this));
58        _supply(balance);
59
60        emit Swept(balance);
61    }
62
63    /// @notice Determines whether the passed token can be transferred out as an external award.
64    /// @dev Different yield sources will hold the deposits as another kind of token: such a Compound's cToken.  The
65    /// prize strategy should not be allowed to move those tokens.
66    /// @param _externalToken The address of the token to check
67    /// @return True if the token may be awarded, false otherwise
68    function _canAwardExternal(address _externalToken) internal view override returns (bool) {
69        IYieldSource _yieldSource = yieldSource;
70        return (
71            _externalToken != address(_yieldSource) &&
72            _externalToken != _yieldSource.depositToken()
73        );
74    }
75
76    /// @notice Returns the total balance (in asset tokens).  This includes the deposits and interest.
77    /// @return The underlying balance of asset tokens
78    function _balance() internal override returns (uint256) {
79        return yieldSource.balanceOfToken(address(this));
80    }
81
82    /// @notice Returns the address of the ERC20 asset token used for deposits.
83    /// @return Address of the ERC20 asset token.
84    function _token() internal view override returns (IERC20) {
85        return IERC20(yieldSource.depositToken());
86    }
87
88    /// @notice Supplies asset tokens to the yield source.
89    /// @param _mintAmount The amount of asset tokens to be supplied
90    function _supply(uint256 _mintAmount) internal override {
91        _token().safeIncreaseAllowance(address(yieldSource), _mintAmount);
92        yieldSource.supplyTokenTo(_mintAmount, address(this));
93    }
94
95    /// @notice Redeems asset tokens from the yield source.
96    /// @param _redeemAmount The amount of yield-bearing tokens to be redeemed
97    /// @return The actual amount of tokens that were redeemed.
98    function _redeem(uint256 _redeemAmount) internal override returns (uint256) {
99        return yieldSource.redeemToken(_redeemAmount);
100    }
101}