|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
pragma solidity ^0.6.0;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
abstract contract Proxy {
|
|
|
|
|
|
|
|
|
|
fallback () payable external {
|
|
_fallback();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
receive () payable external {
|
|
_fallback();
|
|
}
|
|
|
|
|
|
|
|
|
|
function _implementation() internal virtual view returns (address);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _delegate(address implementation) internal {
|
|
assembly {
|
|
|
|
|
|
|
|
calldatacopy(0, 0, calldatasize())
|
|
|
|
|
|
|
|
let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
|
|
|
|
// Copy the returned data.
|
|
returndatacopy(0, 0, returndatasize())
|
|
|
|
switch result
|
|
// delegatecall returns 0 on error.
|
|
case 0 { revert(0, returndatasize()) }
|
|
default { return(0, returndatasize()) }
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function _willFallback() internal virtual {
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
function _fallback() internal {
|
|
_willFallback();
|
|
_delegate(_implementation());
|
|
}
|
|
}
|
|
|
|
|
|
|
|
pragma solidity >=0.6.2 <0.8.0;
|
|
|
|
|
|
|
|
|
|
library Address {
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function isContract(address account) internal view returns (bool) {
|
|
|
|
|
|
|
|
|
|
uint256 size;
|
|
|
|
assembly { size := extcodesize(account) }
|
|
return size > 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
function sendValue(address payable recipient, uint256 amount) internal {
|
|
require(address(this).balance >= amount, "Address: insufficient balance");
|
|
|
|
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
|
|
(bool success, ) = recipient.call{ value: amount }("");
|
|
require(success, "Address: unable to send value, recipient may have reverted");
|
|
}
|
|
|
|
/**
|
|
* @dev Performs a Solidity function call using a low level `call`. A
|
|
* plain`call` is an unsafe replacement for a function call: use this
|
|
* function instead.
|
|
*
|
|
* If `target` reverts with a revert reason, it is bubbled up by this
|
|
* function (like regular Solidity function calls).
|
|
*
|
|
* Returns the raw returned data. To convert to the expected return value,
|
|
* use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
|
|
*
|
|
* Requirements:
|
|
*
|
|
* - `target` must be a contract.
|
|
* - calling `target` with `data` must not revert.
|
|
*
|
|
* _Available since v3.1._
|
|
*/
|
|
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
|
|
return functionCall(target, data, "Address: low-level call failed");
|
|
}
|
|
|
|
/**
|
|
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
|
|
* `errorMessage` as a fallback revert reason when `target` reverts.
|
|
*
|
|
* _Available since v3.1._
|
|
*/
|
|
function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
|
|
return functionCallWithValue(target, data, 0, errorMessage);
|
|
}
|
|
|
|
/**
|
|
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
|
|
* but also transferring `value` wei to `target`.
|
|
*
|
|
* Requirements:
|
|
*
|
|
* - the calling contract must have an ETH balance of at least `value`.
|
|
* - the called Solidity function must be `payable`.
|
|
*
|
|
* _Available since v3.1._
|
|
*/
|
|
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");
|
|
}
|
|
|
|
/**
|
|
* @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
|
|
* with `errorMessage` as a fallback revert reason when `target` reverts.
|
|
*
|
|
* _Available since v3.1._
|
|
*/
|
|
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");
|
|
|
|
// solhint-disable-next-line avoid-low-level-calls
|
|
(bool success, bytes memory returndata) = target.call{ value: value }(data);
|
|
return _verifyCallResult(success, returndata, errorMessage);
|
|
}
|
|
|
|
/**
|
|
* @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
|
|
* but performing a static call.
|
|
*
|
|
* _Available since v3.3._
|
|
*/
|
|
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
|
|
return functionStaticCall(target, data, "Address: low-level static call failed");
|
|
}
|
|
|
|
/**
|
|
* @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
|
|
* but performing a static call.
|
|
*
|
|
* _Available since v3.3._
|
|
*/
|
|
function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
|
|
require(isContract(target), "Address: static call to non-contract");
|
|
|
|
// solhint-disable-next-line avoid-low-level-calls
|
|
(bool success, bytes memory returndata) = target.staticcall(data);
|
|
return _verifyCallResult(success, returndata, errorMessage);
|
|
}
|
|
|
|
function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
|
|
if (success) {
|
|
return returndata;
|
|
} else {
|
|
// Look for revert reason and bubble it up if present
|
|
if (returndata.length > 0) {
|
|
// The easiest way to bubble the revert reason is using memory via assembly
|
|
|
|
// solhint-disable-next-line no-inline-assembly
|
|
assembly {
|
|
let returndata_size := mload(returndata)
|
|
revert(add(32, returndata), returndata_size)
|
|
}
|
|
} else {
|
|
revert(errorMessage);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// File: MasterChef/contracts-proxy/UpgradeabilityProxy.sol
|
|
|
|
pragma solidity ^0.6.0;
|
|
|
|
|
|
|
|
/**
|
|
* @title UpgradeabilityProxy
|
|
* @dev This contract implements a proxy that allows to change the
|
|
* implementation address to which it will delegate.
|
|
* Such a change is called an implementation upgrade.
|
|
*/
|
|
contract UpgradeabilityProxy is Proxy {
|
|
/**
|
|
* @dev Contract constructor.
|
|
* @param _logic Address of the initial implementation.
|
|
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
|
|
* It should include the signature and the parameters of the function to be called, as described in
|
|
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
|
|
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
|
|
*/
|
|
constructor(address _logic, bytes memory _data) public payable {
|
|
assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256('eip1967.proxy.implementation')) - 1));
|
|
_setImplementation(_logic);
|
|
if(_data.length > 0) {
|
|
(bool success,) = _logic.delegatecall(_data);
|
|
require(success);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Emitted when the implementation is upgraded.
|
|
* @param implementation Address of the new implementation.
|
|
*/
|
|
event Upgraded(address indexed implementation);
|
|
|
|
/**
|
|
* @dev Storage slot with the address of the current implementation.
|
|
* This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
|
|
* validated in the constructor.
|
|
*/
|
|
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
|
|
|
|
/**
|
|
* @dev Returns the current implementation.
|
|
* @return impl Address of the current implementation
|
|
*/
|
|
function _implementation() internal override view returns (address impl) {
|
|
bytes32 slot = IMPLEMENTATION_SLOT;
|
|
assembly {
|
|
impl := sload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Upgrades the proxy to a new implementation.
|
|
* @param newImplementation Address of the new implementation.
|
|
*/
|
|
function _upgradeTo(address newImplementation) internal {
|
|
_setImplementation(newImplementation);
|
|
emit Upgraded(newImplementation);
|
|
}
|
|
|
|
/**
|
|
* @dev Sets the implementation address of the proxy.
|
|
* @param newImplementation Address of the new implementation.
|
|
*/
|
|
function _setImplementation(address newImplementation) internal {
|
|
require(Address.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
|
|
|
|
bytes32 slot = IMPLEMENTATION_SLOT;
|
|
|
|
assembly {
|
|
sstore(slot, newImplementation)
|
|
}
|
|
}
|
|
}
|
|
|
|
// File: MasterChef/contracts-proxy/AdminUpgradeabilityProxy.sol
|
|
|
|
pragma solidity ^0.6.0;
|
|
|
|
|
|
/**
|
|
* @title AdminUpgradeabilityProxy
|
|
* @dev This contract combines an upgradeability proxy with an authorization
|
|
* mechanism for administrative tasks.
|
|
* All external functions in this contract must be guarded by the
|
|
* `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
|
|
* feature proposal that would enable this to be done automatically.
|
|
*/
|
|
contract AdminUpgradeabilityProxy is UpgradeabilityProxy {
|
|
/**
|
|
* Contract constructor.
|
|
* @param _logic address of the initial implementation.
|
|
* @param _admin Address of the proxy administrator.
|
|
* It should include the signature and the parameters of the function to be called, as described in
|
|
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
|
|
* This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
|
|
*/
|
|
constructor(address _logic, address _admin) UpgradeabilityProxy(_logic, abi.encodeWithSignature("initialize()")) public payable {
|
|
assert(ADMIN_SLOT == bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1));
|
|
_setAdmin(_admin);
|
|
}
|
|
|
|
/**
|
|
* @dev Emitted when the administration has been transferred.
|
|
* @param previousAdmin Address of the previous admin.
|
|
* @param newAdmin Address of the new admin.
|
|
*/
|
|
event AdminChanged(address previousAdmin, address newAdmin);
|
|
|
|
/**
|
|
* @dev Storage slot with the admin of the contract.
|
|
* This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
|
|
* validated in the constructor.
|
|
*/
|
|
|
|
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
|
|
|
|
/**
|
|
* @dev Modifier to check whether the `msg.sender` is the admin.
|
|
* If it is, it will run the function. Otherwise, it will delegate the call
|
|
* to the implementation.
|
|
*/
|
|
modifier ifAdmin() {
|
|
if (msg.sender == _admin()) {
|
|
_;
|
|
} else {
|
|
_fallback();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @return The address of the proxy admin.
|
|
*/
|
|
function admin() external ifAdmin returns (address) {
|
|
return _admin();
|
|
}
|
|
|
|
/**
|
|
* @return The address of the implementation.
|
|
*/
|
|
function implementation() external ifAdmin returns (address) {
|
|
return _implementation();
|
|
}
|
|
|
|
/**
|
|
* @dev Changes the admin of the proxy.
|
|
* Only the current admin can call this function.
|
|
* @param newAdmin Address to transfer proxy administration to.
|
|
*/
|
|
function changeAdmin(address newAdmin) external ifAdmin {
|
|
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
|
|
emit AdminChanged(_admin(), newAdmin);
|
|
_setAdmin(newAdmin);
|
|
}
|
|
|
|
/**
|
|
* @dev Upgrade the backing implementation of the proxy.
|
|
* Only the admin can call this function.
|
|
* @param newImplementation Address of the new implementation.
|
|
*/
|
|
function upgradeTo(address newImplementation) external ifAdmin {
|
|
_upgradeTo(newImplementation);
|
|
}
|
|
|
|
/**
|
|
* @dev Upgrade the backing implementation of the proxy and call a function
|
|
* on the new implementation.
|
|
* This is useful to initialize the proxied contract.
|
|
* @param newImplementation Address of the new implementation.
|
|
* @param data Data to send as msg.data in the low level call.
|
|
* It should include the signature and the parameters of the function to be called, as described in
|
|
* https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
|
|
*/
|
|
function upgradeToAndCall(address newImplementation, bytes calldata data) payable external ifAdmin {
|
|
_upgradeTo(newImplementation);
|
|
(bool success,) = newImplementation.delegatecall(data);
|
|
require(success);
|
|
}
|
|
|
|
/**
|
|
* @return adm The admin slot.
|
|
*/
|
|
function _admin() internal view returns (address adm) {
|
|
bytes32 slot = ADMIN_SLOT;
|
|
assembly {
|
|
adm := sload(slot)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Sets the address of the proxy admin.
|
|
* @param newAdmin Address of the new proxy admin.
|
|
*/
|
|
function _setAdmin(address newAdmin) internal {
|
|
bytes32 slot = ADMIN_SLOT;
|
|
|
|
assembly {
|
|
sstore(slot, newAdmin)
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @dev Only fall back when the sender is not the admin.
|
|
*/
|
|
function _willFallback() internal override virtual {
|
|
require(msg.sender != _admin(), "Cannot call fallback function from the proxy admin");
|
|
super._willFallback();
|
|
}
|
|
} |