{ "address": "0x6aeBE10a4607B1002ea56D825Ee18Ce751fD9592", "abi": [ { "inputs": [ { "internalType": "contract CTokenInterface", "name": "_cToken", "type": "address" } ], "stateMutability": "nonpayable", "type": "constructor" }, { "anonymous": false, "inputs": [ { "indexed": true, "internalType": "address", "name": "cToken", "type": "address" } ], "name": "CTokenYieldSourceInitialized", "type": "event" }, { "inputs": [ { "internalType": "address", "name": "addr", "type": "address" } ], "name": "balanceOfToken", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "address", "name": "", "type": "address" } ], "name": "balances", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "cToken", "outputs": [ { "internalType": "contract CTokenInterface", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "depositToken", "outputs": [ { "internalType": "address", "name": "", "type": "address" } ], "stateMutability": "view", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "redeemAmount", "type": "uint256" } ], "name": "redeemToken", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [ { "internalType": "uint256", "name": "amount", "type": "uint256" }, { "internalType": "address", "name": "to", "type": "address" } ], "name": "supplyTokenTo", "outputs": [], "stateMutability": "nonpayable", "type": "function" } ], "transactionHash": "0x68a7a8141cc7ad9859a4ae6761b22f4a5f495acb436e6c77ce2c60b686e8fc70", "receipt": { "to": null, "from": "0xE0F4217390221aF47855E094F6e112D43C8698fE", "contractAddress": "0x6aeBE10a4607B1002ea56D825Ee18Ce751fD9592", "transactionIndex": 0, "gasUsed": "742780", "logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000080000000000000000000000400000000000000000000000000000000000000000000000084000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100000000000000000000000002000100000000000002000000000000000000000000000000000000000000000000000000000", "blockHash": "0xfddea892c5df1e007b41d6d1513f2cb57f03e2179600db5145396b2aadac7551", "transactionHash": "0x68a7a8141cc7ad9859a4ae6761b22f4a5f495acb436e6c77ce2c60b686e8fc70", "logs": [ { "transactionIndex": 0, "blockNumber": 26171303, "transactionHash": "0x68a7a8141cc7ad9859a4ae6761b22f4a5f495acb436e6c77ce2c60b686e8fc70", "address": "0x6aeBE10a4607B1002ea56D825Ee18Ce751fD9592", "topics": [ "0x62a988a69bb7d6a98d15b99860212aeed699dd1c1c09f6474948e77f0d4addcb", "0x000000000000000000000000f0d0eb522cfa50b716b3b1604c4f0fa6f04376ad" ], "data": "0x", "logIndex": 0, "blockHash": "0xfddea892c5df1e007b41d6d1513f2cb57f03e2179600db5145396b2aadac7551" } ], "blockNumber": 26171303, "cumulativeGasUsed": "742780", "status": 1, "byzantium": true }, "args": [ "0xF0d0EB522cfa50B716B3b1604C4F0fA6f04376AD" ], "solcInputHash": "07113fc1ebb7a05ae49ea4c62cff423c", "metadata": "{\"compiler\":{\"version\":\"0.6.12+commit.27d51765\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"contract CTokenInterface\",\"name\":\"_cToken\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"cToken\",\"type\":\"address\"}],\"name\":\"CTokenYieldSourceInitialized\",\"type\":\"event\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"addr\",\"type\":\"address\"}],\"name\":\"balanceOfToken\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cToken\",\"outputs\":[{\"internalType\":\"contract CTokenInterface\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"depositToken\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"redeemAmount\",\"type\":\"uint256\"}],\"name\":\"redeemToken\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"}],\"name\":\"supplyTokenTo\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"details\":\"THIS CONTRACT IS EXPERIMENTAL! USE AT YOUR OWN RISK\",\"kind\":\"dev\",\"methods\":{\"balanceOfToken(address)\":{\"returns\":{\"_0\":\"The underlying balance of asset tokens\"}},\"constructor\":{\"params\":{\"_cToken\":\"Address of the Compound cToken interface\"}},\"depositToken()\":{\"returns\":{\"_0\":\"The ERC20 asset token\"}},\"redeemToken(uint256)\":{\"params\":{\"redeemAmount\":\"The amount of yield-bearing tokens to be redeemed\"},\"returns\":{\"_0\":\"The actual amount of tokens that were redeemed.\"}},\"supplyTokenTo(uint256,address)\":{\"params\":{\"amount\":\"The amount of asset tokens to be supplied\"}}},\"title\":\"Defines the functions used to interact with a yield source. The Prize Pool inherits this contract.\",\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{\"balanceOfToken(address)\":{\"notice\":\"Returns the total balance (in asset tokens). This includes the deposits and interest.\"},\"cToken()\":{\"notice\":\"Interface for the Yield-bearing cToken by Compound\"},\"constructor\":\"Initializes the Yield Service with the Compound cToken\",\"depositToken()\":{\"notice\":\"Returns the ERC20 asset token used for deposits.\"},\"redeemToken(uint256)\":{\"notice\":\"Redeems asset tokens from the yield source.\"},\"supplyTokenTo(uint256,address)\":{\"notice\":\"Supplies asset tokens to the yield source.\"}},\"notice\":\"Prize Pools subclasses need to implement this interface so that yield can be generated.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/yield-source/CTokenYieldSource.sol\":\"CTokenYieldSource\"},\"evmVersion\":\"istanbul\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\",\"useLiteralContent\":true},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[]},\"sources\":{\"@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.6.0 <0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary SafeMathUpgradeable {\\n /**\\n * @dev Returns the addition of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n uint256 c = a + b;\\n if (c < a) return (false, 0);\\n return (true, c);\\n }\\n\\n /**\\n * @dev Returns the substraction of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n if (b > a) return (false, 0);\\n return (true, a - b);\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, with an overflow flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) return (true, 0);\\n uint256 c = a * b;\\n if (c / a != b) return (false, 0);\\n return (true, c);\\n }\\n\\n /**\\n * @dev Returns the division of two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n if (b == 0) return (false, 0);\\n return (true, a / b);\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.\\n *\\n * _Available since v3.4._\\n */\\n function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {\\n if (b == 0) return (false, 0);\\n return (true, a % b);\\n }\\n\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(c >= a, \\\"SafeMath: addition overflow\\\");\\n return c;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n require(b <= a, \\\"SafeMath: subtraction overflow\\\");\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n if (a == 0) return 0;\\n uint256 c = a * b;\\n require(c / a == b, \\\"SafeMath: multiplication overflow\\\");\\n return c;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n require(b > 0, \\\"SafeMath: division by zero\\\");\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n require(b > 0, \\\"SafeMath: modulo by zero\\\");\\n return a % b;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {trySub}.\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b <= a, errorMessage);\\n return a - b;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers, reverting with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryDiv}.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b > 0, errorMessage);\\n return a / b;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * reverting with custom message when dividing by zero.\\n *\\n * CAUTION: This function is deprecated because it requires allocating memory for the error\\n * message unnecessarily. For custom revert reasons use {tryMod}.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b > 0, errorMessage);\\n return a % b;\\n }\\n}\\n\",\"keccak256\":\"0x0dd1e9b19801e3e7d900fbf4182d81e1afd23ad7be39504e33df6bbcba91d724\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/proxy/Initializable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// solhint-disable-next-line compiler-version\\npragma solidity >=0.4.24 <0.8.0;\\n\\nimport \\\"../utils/AddressUpgradeable.sol\\\";\\n\\n/**\\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\\n *\\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\\n * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.\\n *\\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\\n */\\nabstract contract Initializable {\\n\\n /**\\n * @dev Indicates that the contract has been initialized.\\n */\\n bool private _initialized;\\n\\n /**\\n * @dev Indicates that the contract is in the process of being initialized.\\n */\\n bool private _initializing;\\n\\n /**\\n * @dev Modifier to protect an initializer function from being invoked twice.\\n */\\n modifier initializer() {\\n require(_initializing || _isConstructor() || !_initialized, \\\"Initializable: contract is already initialized\\\");\\n\\n bool isTopLevelCall = !_initializing;\\n if (isTopLevelCall) {\\n _initializing = true;\\n _initialized = true;\\n }\\n\\n _;\\n\\n if (isTopLevelCall) {\\n _initializing = false;\\n }\\n }\\n\\n /// @dev Returns true if and only if the function is running in the constructor\\n function _isConstructor() private view returns (bool) {\\n return !AddressUpgradeable.isContract(address(this));\\n }\\n}\\n\",\"keccak256\":\"0xd8e4eb08dcc1d1860fb347ba5ffd595242b9a1b66d49a47f2b4cb51c3f35017e\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.6.0 <0.8.0;\\n\\n/**\\n * @dev Interface of the ERC20 standard as defined in the EIP.\\n */\\ninterface IERC20Upgradeable {\\n /**\\n * @dev Returns the amount of tokens in existence.\\n */\\n function totalSupply() external view returns (uint256);\\n\\n /**\\n * @dev Returns the amount of tokens owned by `account`.\\n */\\n function balanceOf(address account) external view returns (uint256);\\n\\n /**\\n * @dev Moves `amount` tokens from the caller's account to `recipient`.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transfer(address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Returns the remaining number of tokens that `spender` will be\\n * allowed to spend on behalf of `owner` through {transferFrom}. This is\\n * zero by default.\\n *\\n * This value changes when {approve} or {transferFrom} are called.\\n */\\n function allowance(address owner, address spender) external view returns (uint256);\\n\\n /**\\n * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * IMPORTANT: Beware that changing an allowance with this method brings the risk\\n * that someone may use both the old and the new allowance by unfortunate\\n * transaction ordering. One possible solution to mitigate this race\\n * condition is to first reduce the spender's allowance to 0 and set the\\n * desired value afterwards:\\n * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\\n *\\n * Emits an {Approval} event.\\n */\\n function approve(address spender, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Moves `amount` tokens from `sender` to `recipient` using the\\n * allowance mechanism. `amount` is then deducted from the caller's\\n * allowance.\\n *\\n * Returns a boolean value indicating whether the operation succeeded.\\n *\\n * Emits a {Transfer} event.\\n */\\n function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);\\n\\n /**\\n * @dev Emitted when `value` tokens are moved from one account (`from`) to\\n * another (`to`).\\n *\\n * Note that `value` may be zero.\\n */\\n event Transfer(address indexed from, address indexed to, uint256 value);\\n\\n /**\\n * @dev Emitted when the allowance of a `spender` for an `owner` is set by\\n * a call to {approve}. `value` is the new allowance.\\n */\\n event Approval(address indexed owner, address indexed spender, uint256 value);\\n}\\n\",\"keccak256\":\"0xa1931c47a617014f858580db625aa0dcf343796f39acd4b5b51effc092a1f0a9\",\"license\":\"MIT\"},\"@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.6.2 <0.8.0;\\n\\n/**\\n * @dev Collection of functions related to the address type\\n */\\nlibrary AddressUpgradeable {\\n /**\\n * @dev Returns true if `account` is a contract.\\n *\\n * [IMPORTANT]\\n * ====\\n * It is unsafe to assume that an address for which this function returns\\n * false is an externally-owned account (EOA) and not a contract.\\n *\\n * Among others, `isContract` will return false for the following\\n * types of addresses:\\n *\\n * - an externally-owned account\\n * - a contract in construction\\n * - an address where a contract will be created\\n * - an address where a contract lived, but was destroyed\\n * ====\\n */\\n function isContract(address account) internal view returns (bool) {\\n // This method relies on extcodesize, which returns 0 for contracts in\\n // construction, since the code is only stored at the end of the\\n // constructor execution.\\n\\n uint256 size;\\n // solhint-disable-next-line no-inline-assembly\\n assembly { size := extcodesize(account) }\\n return size > 0;\\n }\\n\\n /**\\n * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\\n * `recipient`, forwarding all available gas and reverting on errors.\\n *\\n * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\\n * of certain opcodes, possibly making contracts go over the 2300 gas limit\\n * imposed by `transfer`, making them unable to receive funds via\\n * `transfer`. {sendValue} removes this limitation.\\n *\\n * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\\n *\\n * IMPORTANT: because control is transferred to `recipient`, care must be\\n * taken to not create reentrancy vulnerabilities. Consider using\\n * {ReentrancyGuard} or the\\n * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\\n */\\n function sendValue(address payable recipient, uint256 amount) internal {\\n require(address(this).balance >= amount, \\\"Address: insufficient balance\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls, avoid-call-value\\n (bool success, ) = recipient.call{ value: amount }(\\\"\\\");\\n require(success, \\\"Address: unable to send value, recipient may have reverted\\\");\\n }\\n\\n /**\\n * @dev Performs a Solidity function call using a low level `call`. A\\n * plain`call` is an unsafe replacement for a function call: use this\\n * function instead.\\n *\\n * If `target` reverts with a revert reason, it is bubbled up by this\\n * function (like regular Solidity function calls).\\n *\\n * Returns the raw returned data. To convert to the expected return value,\\n * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\\n *\\n * Requirements:\\n *\\n * - `target` must be a contract.\\n * - calling `target` with `data` must not revert.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data) internal returns (bytes memory) {\\n return functionCall(target, data, \\\"Address: low-level call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\\n * `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, 0, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but also transferring `value` wei to `target`.\\n *\\n * Requirements:\\n *\\n * - the calling contract must have an ETH balance of at least `value`.\\n * - the called Solidity function must be `payable`.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {\\n return functionCallWithValue(target, data, value, \\\"Address: low-level call with value failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\\n * with `errorMessage` as a fallback revert reason when `target` reverts.\\n *\\n * _Available since v3.1._\\n */\\n function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {\\n require(address(this).balance >= value, \\\"Address: insufficient balance for call\\\");\\n require(isContract(target), \\\"Address: call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.call{ value: value }(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\\n return functionStaticCall(target, data, \\\"Address: low-level static call failed\\\");\\n }\\n\\n /**\\n * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\\n * but performing a static call.\\n *\\n * _Available since v3.3._\\n */\\n function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {\\n require(isContract(target), \\\"Address: static call to non-contract\\\");\\n\\n // solhint-disable-next-line avoid-low-level-calls\\n (bool success, bytes memory returndata) = target.staticcall(data);\\n return _verifyCallResult(success, returndata, errorMessage);\\n }\\n\\n function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {\\n if (success) {\\n return returndata;\\n } else {\\n // Look for revert reason and bubble it up if present\\n if (returndata.length > 0) {\\n // The easiest way to bubble the revert reason is using memory via assembly\\n\\n // solhint-disable-next-line no-inline-assembly\\n assembly {\\n let returndata_size := mload(returndata)\\n revert(add(32, returndata), returndata_size)\\n }\\n } else {\\n revert(errorMessage);\\n }\\n }\\n }\\n}\\n\",\"keccak256\":\"0xfc5ea91fa9ceb1961023b2a6c978b902888c52b90847ac7813fe3b79524165f6\",\"license\":\"MIT\"},\"@pooltogether/fixed-point/contracts/FixedPoint.sol\":{\"content\":\"/**\\nCopyright 2020 PoolTogether Inc.\\n\\nThis file is part of PoolTogether.\\n\\nPoolTogether is free software: you can redistribute it and/or modify\\nit under the terms of the GNU General Public License as published by\\nthe Free Software Foundation under version 3 of the License.\\n\\nPoolTogether is distributed in the hope that it will be useful,\\nbut WITHOUT ANY WARRANTY; without even the implied warranty of\\nMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\\nGNU General Public License for more details.\\n\\nYou should have received a copy of the GNU General Public License\\nalong with PoolTogether. If not, see .\\n*/\\n\\npragma solidity >=0.6.0 <0.8.0;\\n\\nimport \\\"./external/openzeppelin/OpenZeppelinSafeMath_V3_3_0.sol\\\";\\n\\n/**\\n * @author Brendan Asselstine\\n * @notice Provides basic fixed point math calculations.\\n *\\n * This library calculates integer fractions by scaling values by 1e18 then performing standard integer math.\\n */\\nlibrary FixedPoint {\\n using OpenZeppelinSafeMath_V3_3_0 for uint256;\\n\\n // The scale to use for fixed point numbers. Same as Ether for simplicity.\\n uint256 internal constant SCALE = 1e18;\\n\\n /**\\n * Calculates a Fixed18 mantissa given the numerator and denominator\\n *\\n * The mantissa = (numerator * 1e18) / denominator\\n *\\n * @param numerator The mantissa numerator\\n * @param denominator The mantissa denominator\\n * @return The mantissa of the fraction\\n */\\n function calculateMantissa(uint256 numerator, uint256 denominator) internal pure returns (uint256) {\\n uint256 mantissa = numerator.mul(SCALE);\\n mantissa = mantissa.div(denominator);\\n return mantissa;\\n }\\n\\n /**\\n * Multiplies a Fixed18 number by an integer.\\n *\\n * @param b The whole integer to multiply\\n * @param mantissa The Fixed18 number\\n * @return An integer that is the result of multiplying the params.\\n */\\n function multiplyUintByMantissa(uint256 b, uint256 mantissa) internal pure returns (uint256) {\\n uint256 result = mantissa.mul(b);\\n result = result.div(SCALE);\\n return result;\\n }\\n\\n /**\\n * Divides an integer by a fixed point 18 mantissa\\n *\\n * @param dividend The integer to divide\\n * @param mantissa The fixed point 18 number to serve as the divisor\\n * @return An integer that is the result of dividing an integer by a fixed point 18 mantissa\\n */\\n function divideUintByMantissa(uint256 dividend, uint256 mantissa) internal pure returns (uint256) {\\n uint256 result = SCALE.mul(dividend);\\n result = result.div(mantissa);\\n return result;\\n }\\n}\\n\",\"keccak256\":\"0x282e7d707b1e604481fed02d1290cde78470e288d3469940c2edf9e5b8a10d99\"},\"@pooltogether/fixed-point/contracts/external/openzeppelin/OpenZeppelinSafeMath_V3_3_0.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\n// NOTE: Copied from OpenZeppelin Contracts version 3.3.0\\n\\npragma solidity >=0.6.0 <0.8.0;\\n\\n/**\\n * @dev Wrappers over Solidity's arithmetic operations with added overflow\\n * checks.\\n *\\n * Arithmetic operations in Solidity wrap on overflow. This can easily result\\n * in bugs, because programmers usually assume that an overflow raises an\\n * error, which is the standard behavior in high level programming languages.\\n * `SafeMath` restores this intuition by reverting the transaction when an\\n * operation overflows.\\n *\\n * Using this library instead of the unchecked operations eliminates an entire\\n * class of bugs, so it's recommended to use it always.\\n */\\nlibrary OpenZeppelinSafeMath_V3_3_0 {\\n /**\\n * @dev Returns the addition of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `+` operator.\\n *\\n * Requirements:\\n *\\n * - Addition cannot overflow.\\n */\\n function add(uint256 a, uint256 b) internal pure returns (uint256) {\\n uint256 c = a + b;\\n require(c >= a, \\\"SafeMath: addition overflow\\\");\\n\\n return c;\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b) internal pure returns (uint256) {\\n return sub(a, b, \\\"SafeMath: subtraction overflow\\\");\\n }\\n\\n /**\\n * @dev Returns the subtraction of two unsigned integers, reverting with custom message on\\n * overflow (when the result is negative).\\n *\\n * Counterpart to Solidity's `-` operator.\\n *\\n * Requirements:\\n *\\n * - Subtraction cannot overflow.\\n */\\n function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b <= a, errorMessage);\\n uint256 c = a - b;\\n\\n return c;\\n }\\n\\n /**\\n * @dev Returns the multiplication of two unsigned integers, reverting on\\n * overflow.\\n *\\n * Counterpart to Solidity's `*` operator.\\n *\\n * Requirements:\\n *\\n * - Multiplication cannot overflow.\\n */\\n function mul(uint256 a, uint256 b) internal pure returns (uint256) {\\n // Gas optimization: this is cheaper than requiring 'a' not being zero, but the\\n // benefit is lost if 'b' is also tested.\\n // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522\\n if (a == 0) {\\n return 0;\\n }\\n\\n uint256 c = a * b;\\n require(c / a == b, \\\"SafeMath: multiplication overflow\\\");\\n\\n return c;\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers. Reverts on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b) internal pure returns (uint256) {\\n return div(a, b, \\\"SafeMath: division by zero\\\");\\n }\\n\\n /**\\n * @dev Returns the integer division of two unsigned integers. Reverts with custom message on\\n * division by zero. The result is rounded towards zero.\\n *\\n * Counterpart to Solidity's `/` operator. Note: this function uses a\\n * `revert` opcode (which leaves remaining gas untouched) while Solidity\\n * uses an invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b > 0, errorMessage);\\n uint256 c = a / b;\\n // assert(a == b * c + a % b); // There is no case in which this doesn't hold\\n\\n return c;\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * Reverts when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b) internal pure returns (uint256) {\\n return mod(a, b, \\\"SafeMath: modulo by zero\\\");\\n }\\n\\n /**\\n * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),\\n * Reverts with custom message when dividing by zero.\\n *\\n * Counterpart to Solidity's `%` operator. This function uses a `revert`\\n * opcode (which leaves remaining gas untouched) while Solidity uses an\\n * invalid opcode to revert (consuming all remaining gas).\\n *\\n * Requirements:\\n *\\n * - The divisor cannot be zero.\\n */\\n function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {\\n require(b != 0, errorMessage);\\n return a % b;\\n }\\n}\\n\",\"keccak256\":\"0xd57327a27dee007aead634ed97dd9ffa42b2626eb2731368650c9cb0e50e73d4\",\"license\":\"MIT\"},\"@pooltogether/yield-source-interface/contracts/IYieldSource.sol\":{\"content\":\"// SPDX-License-Identifier: MIT\\n\\npragma solidity >=0.4.0 <0.8.0;\\n\\n/// @title Defines the functions used to interact with a yield source. The Prize Pool inherits this contract.\\n/// @notice Prize Pools subclasses need to implement this interface so that yield can be generated.\\ninterface IYieldSource {\\n\\n /// @notice Returns the ERC20 asset token used for deposits.\\n /// @return The ERC20 asset token\\n function depositToken() external view returns (address);\\n\\n /// @notice Returns the total balance (in asset tokens). This includes the deposits and interest.\\n /// @return The underlying balance of asset tokens\\n function balanceOfToken(address addr) external returns (uint256);\\n\\n /// @notice Supplies tokens to the yield source. Allows assets to be supplied on other user's behalf using the `to` param.\\n /// @param amount The amount of `token()` to be supplied\\n /// @param to The user whose balance will receive the tokens\\n function supplyTokenTo(uint256 amount, address to) external;\\n\\n /// @notice Redeems tokens from the yield source.\\n /// @param amount The amount of `token()` to withdraw. Denominated in `token()` as above.\\n /// @return The actual amount of tokens that were redeemed.\\n function redeemToken(uint256 amount) external returns (uint256);\\n\\n}\\n\",\"keccak256\":\"0xee862089c29ec1f9b2a1df7c01953d88ef5dfcfb2c2198e8926f692ec76537f1\",\"license\":\"MIT\"},\"contracts/external/compound/CTokenInterface.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity 0.6.12;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\n\\ninterface CTokenInterface is IERC20Upgradeable {\\n function decimals() external view returns (uint8);\\n function totalSupply() external override view returns (uint256);\\n function underlying() external view returns (address);\\n function balanceOfUnderlying(address owner) external returns (uint256);\\n function supplyRatePerBlock() external returns (uint256);\\n function exchangeRateCurrent() external returns (uint256);\\n function mint(uint256 mintAmount) external returns (uint256);\\n function redeem(uint256 amount) external returns (uint256);\\n function balanceOf(address user) external override view returns (uint256);\\n function redeemUnderlying(uint256 redeemAmount) external returns (uint256);\\n}\\n\",\"keccak256\":\"0x9608049458bc017f2369e2af2a20bfa2efaff1a5b451a17bd0594a976d5bc88f\",\"license\":\"GPL-3.0\"},\"contracts/yield-source/CTokenYieldSource.sol\":{\"content\":\"// SPDX-License-Identifier: GPL-3.0\\n\\npragma solidity 0.6.12;\\n\\nimport \\\"@openzeppelin/contracts-upgradeable/proxy/Initializable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport \\\"@pooltogether/fixed-point/contracts/FixedPoint.sol\\\";\\nimport \\\"@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol\\\";\\nimport \\\"@pooltogether/yield-source-interface/contracts/IYieldSource.sol\\\";\\n\\nimport \\\"../external/compound/CTokenInterface.sol\\\";\\n\\n/// @title Defines the functions used to interact with a yield source. The Prize Pool inherits this contract.\\n/// @dev THIS CONTRACT IS EXPERIMENTAL! USE AT YOUR OWN RISK\\n/// @notice Prize Pools subclasses need to implement this interface so that yield can be generated.\\ncontract CTokenYieldSource is IYieldSource {\\n using SafeMathUpgradeable for uint256;\\n\\n event CTokenYieldSourceInitialized(address indexed cToken);\\n\\n mapping(address => uint256) public balances;\\n\\n /// @notice Interface for the Yield-bearing cToken by Compound\\n CTokenInterface public cToken;\\n\\n /// @notice Initializes the Yield Service with the Compound cToken\\n /// @param _cToken Address of the Compound cToken interface\\n constructor (\\n CTokenInterface _cToken\\n )\\n public\\n {\\n cToken = _cToken;\\n\\n emit CTokenYieldSourceInitialized(address(cToken));\\n }\\n\\n /// @notice Returns the ERC20 asset token used for deposits.\\n /// @return The ERC20 asset token\\n function depositToken() public override view returns (address) {\\n return _tokenAddress();\\n }\\n\\n function _tokenAddress() internal view returns (address) {\\n return cToken.underlying();\\n }\\n\\n function _token() internal view returns (IERC20Upgradeable) {\\n return IERC20Upgradeable(_tokenAddress());\\n }\\n\\n /// @notice Returns the total balance (in asset tokens). This includes the deposits and interest.\\n /// @return The underlying balance of asset tokens\\n function balanceOfToken(address addr) external override returns (uint256) {\\n uint256 totalUnderlying = cToken.balanceOfUnderlying(address(this));\\n uint256 total = cToken.balanceOf(address(this));\\n if (total == 0) {\\n return 0;\\n }\\n return balances[addr].mul(totalUnderlying).div(total);\\n }\\n\\n /// @notice Supplies asset tokens to the yield source.\\n /// @param amount The amount of asset tokens to be supplied\\n function supplyTokenTo(uint256 amount, address to) external override {\\n _token().transferFrom(msg.sender, address(this), amount);\\n IERC20Upgradeable(cToken.underlying()).approve(address(cToken), amount);\\n uint256 cTokenBalanceBefore = cToken.balanceOf(address(this));\\n require(cToken.mint(amount) == 0, \\\"CTokenYieldSource/mint-failed\\\");\\n uint256 cTokenDiff = cToken.balanceOf(address(this)).sub(cTokenBalanceBefore);\\n balances[to] = balances[to].add(cTokenDiff);\\n }\\n\\n /// @notice Redeems asset tokens from the yield source.\\n /// @param redeemAmount The amount of yield-bearing tokens to be redeemed\\n /// @return The actual amount of tokens that were redeemed.\\n function redeemToken(uint256 redeemAmount) external override returns (uint256) {\\n uint256 cTokenBalanceBefore = cToken.balanceOf(address(this));\\n uint256 balanceBefore = _token().balanceOf(address(this));\\n require(cToken.redeemUnderlying(redeemAmount) == 0, \\\"CTokenYieldSource/redeem-failed\\\");\\n uint256 cTokenDiff = cTokenBalanceBefore.sub(cToken.balanceOf(address(this)));\\n uint256 diff = _token().balanceOf(address(this)).sub(balanceBefore);\\n balances[msg.sender] = balances[msg.sender].sub(cTokenDiff);\\n _token().transfer(msg.sender, diff);\\n return diff;\\n }\\n}\\n\",\"keccak256\":\"0x89bdc996bf8f5350dd9867e35c30c593174a4f0868df16c290b816b4b2dccc5c\",\"license\":\"GPL-3.0\"}},\"version\":1}", "bytecode": "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", "deployedBytecode": "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", "devdoc": { "details": "THIS CONTRACT IS EXPERIMENTAL! USE AT YOUR OWN RISK", "kind": "dev", "methods": { "balanceOfToken(address)": { "returns": { "_0": "The underlying balance of asset tokens" } }, "constructor": { "params": { "_cToken": "Address of the Compound cToken interface" } }, "depositToken()": { "returns": { "_0": "The ERC20 asset token" } }, "redeemToken(uint256)": { "params": { "redeemAmount": "The amount of yield-bearing tokens to be redeemed" }, "returns": { "_0": "The actual amount of tokens that were redeemed." } }, "supplyTokenTo(uint256,address)": { "params": { "amount": "The amount of asset tokens to be supplied" } } }, "title": "Defines the functions used to interact with a yield source. The Prize Pool inherits this contract.", "version": 1 }, "userdoc": { "kind": "user", "methods": { "balanceOfToken(address)": { "notice": "Returns the total balance (in asset tokens). This includes the deposits and interest." }, "cToken()": { "notice": "Interface for the Yield-bearing cToken by Compound" }, "constructor": "Initializes the Yield Service with the Compound cToken", "depositToken()": { "notice": "Returns the ERC20 asset token used for deposits." }, "redeemToken(uint256)": { "notice": "Redeems asset tokens from the yield source." }, "supplyTokenTo(uint256,address)": { "notice": "Supplies asset tokens to the yield source." } }, "notice": "Prize Pools subclasses need to implement this interface so that yield can be generated.", "version": 1 }, "storageLayout": { "storage": [ { "astId": 16945, "contract": "contracts/yield-source/CTokenYieldSource.sol:CTokenYieldSource", "label": "balances", "offset": 0, "slot": "0", "type": "t_mapping(t_address,t_uint256)" }, { "astId": 16948, "contract": "contracts/yield-source/CTokenYieldSource.sol:CTokenYieldSource", "label": "cToken", "offset": 0, "slot": "1", "type": "t_contract(CTokenInterface)6650" } ], "types": { "t_address": { "encoding": "inplace", "label": "address", "numberOfBytes": "20" }, "t_contract(CTokenInterface)6650": { "encoding": "inplace", "label": "contract CTokenInterface", "numberOfBytes": "20" }, "t_mapping(t_address,t_uint256)": { "encoding": "mapping", "key": "t_address", "label": "mapping(address => uint256)", "numberOfBytes": "32", "value": "t_uint256" }, "t_uint256": { "encoding": "inplace", "label": "uint256", "numberOfBytes": "32" } } } }