ApprovalReceiver.sol

pragma solidity ^0.5.17;

import "./ErrorDecoder.sol";
import "../token/IApproveAndCall.sol";

/**
 * @title Base contract for receiving approval from SOV token.
 */
contract ApprovalReceiver is ErrorDecoder, IApproveAndCall {
    modifier onlyThisContract() {
        // Accepts calls only from receiveApproval function.
        require(msg.sender == address(this), "unauthorized");
        _;
    }

    /**
     * @notice Receives approval from SOV token.
     * @param _data The data will be used for low level call.
     */
    function receiveApproval(
        address _sender,
        uint256 _amount,
        address _token,
        bytes calldata _data
    ) external {
        // Accepts calls only from SOV token.
        require(msg.sender == _getToken(), "unauthorized");
        require(msg.sender == _token, "unauthorized");

        // Only allowed methods.
        bool isAllowed = false;
        bytes4[] memory selectors = _getSelectors();
        bytes4 sig = _getSig(_data);
        for (uint256 i = 0; i < selectors.length; i++) {
            if (sig == selectors[i]) {
                isAllowed = true;
                break;
            }
        }
        require(isAllowed, "method is not allowed");

        // Check sender and amount.
        address sender;
        uint256 amount;
        (, sender, amount) = abi.decode(
            abi.encodePacked(bytes28(0), _data),
            (bytes32, address, uint256)
        );
        require(sender == _sender, "sender mismatch");
        require(amount == _amount, "amount mismatch");

        _call(_data);
    }

    /**
     * @notice Returns token address, only this address can be a sender for receiveApproval.
     * @dev Should be overridden in child contracts, otherwise error will be thrown.
     * @return By default, 0x. When overriden, the token address making the call.
     */
    function _getToken() internal view returns (address) {
        return address(0);
    }

    /**
     * @notice Returns list of function selectors allowed to be invoked.
     * @dev Should be overridden in child contracts, otherwise error will be thrown.
     * @return By default, empty array. When overriden, allowed selectors.
     */
    function _getSelectors() internal pure returns (bytes4[] memory) {
        return new bytes4[](0);
    }

    /**
     * @notice Makes call and reverts w/ enhanced error message.
     * @param _data Error message as bytes.
     */
    function _call(bytes memory _data) internal {
        (bool success, bytes memory returnData) = address(this).call(_data);
        if (!success) {
            if (returnData.length <= ERROR_MESSAGE_SHIFT) {
                revert("receiveApproval: Transaction execution reverted.");
            } else {
                revert(_addErrorMessage("receiveApproval: ", string(returnData)));
            }
        }
    }

    /**
     * @notice Extracts the called function selector, a hash of the signature.
     * @dev The first four bytes of the call data for a function call specifies
     * the function to be called. It is the first (left, high-order in big-endian)
     * four bytes of the Keccak-256 (SHA-3) hash of the signature of the function.
     * Solidity doesn't yet support a casting of byte[4] to bytes4.
     * Example:
     *  msg.data:
     *    0xcdcd77c000000000000000000000000000000000000000000000000000000000000
     *    000450000000000000000000000000000000000000000000000000000000000000001
     *  selector (or method ID): 0xcdcd77c0
     *  signature: baz(uint32,bool)
     * @param _data The msg.data from the low level call.
     * @return sig First 4 bytes of msg.data i.e. the selector, hash of the signature.
     */
    function _getSig(bytes memory _data) internal pure returns (bytes4 sig) {
        assembly {
            sig := mload(add(_data, 32))
        }
    }
}