Add ERC20Charge recipients

contracts/drafts/meta-tx/GSNRecipientERC20BuiltInCharge.sol

@@ -0,0 +1,57 @@
+pragma solidity ^0.5.0;
+
+import "./GSNRecipientERC20Charge.sol";
+import "../../token/ERC20/ERC20.sol";
+import "../../token/ERC20/ERC20Detailed.sol";
+import "../../ownership/Secondary.sol";
+
+contract GSNRecipientERC20BuiltInCharge is GSNRecipientERC20Charge {
+    constructor(string memory name, string memory symbol, uint8 decimals) public {
+        _setToken(new __unstable__ERC20PrimaryAdmin(name, symbol, decimals));
+    }
+
+    function _getEquivalentTokens(uint256 weiAmount) internal view returns (uint256) {
+        return weiAmount;
+    }
+
+    function _mintBuiltIn(address account, uint256 amount) internal {
+        // Solidity doesn't allow converting contract types, so we need to go through the intermediate address type
+        __unstable__ERC20PrimaryAdmin(address(token())).mint(account, amount);
+    }
+}
+
+/**
+ * @title __unstable__ERC20PrimaryAdmin
+ * @dev An ERC20 token owned by another contract, which has minting permissions and can use transferFrom to receive
+ * anyone's tokens. This contract is an internal helper for GSNRecipientERC20BuiltInCharge, and should not be used
+ * outside of this context.
+ */
+// solhint-disable-next-line contract-name-camelcase
+contract __unstable__ERC20PrimaryAdmin is ERC20, ERC20Detailed, Secondary {
+    uint256 private constant UINT256_MAX = 2**256 - 1;
+
+    constructor(string memory name, string memory symbol, uint8 decimals) ERC20Detailed(name, symbol, decimals) public { }
+
+    // The primary account (GSNRecipientERC20BuiltInCharge) can mint tokens
+    function mint(address account, uint256 amount) public onlyPrimary {
+        _mint(account, amount);
+    }
+
+    // The primary account has 'infinite' allowance for all token holders
+    function allowance(address owner, address spender) public view returns (uint256) {
+        if (spender == primary()) {
+            return UINT256_MAX;
+        } else {
+            return super.allowance(owner, spender);
+        }
+    }
+
+    // Allowance for the primary account cannot be changed (it is always 'infinite')
+    function _approve(address owner, address spender, uint256 value) internal {
+        if (spender == primary()) {
+            return;
+        } else {
+            super._approve(owner, spender, value);
+        }
+    }
+}

contracts/drafts/meta-tx/GSNRecipientERC20Charge.sol

@@ -0,0 +1,77 @@
+pragma solidity ^0.5.0;
+
+import "./GSNRecipient.sol";
+import "../../math/SafeMath.sol";
+import "../../token/ERC20/IERC20.sol";
+import "../../token/ERC20/SafeERC20.sol";
+
+contract GSNRecipientERC20Charge is GSNRecipient {
+    using SafeERC20 for IERC20;
+    using SafeMath for uint256;
+
+    IERC20 private _token;
+
+    enum GSNRecipientERC20ChargeErrorCodes {
+        INSUFFICIENT_BALANCE,
+        INSUFFICIENT_ALLOWANCE
+    }
+
+    function token() public view returns (IERC20) {
+        return _token;
+    }
+
+    // We provide this as a function instead of a constructor to give more flexibility to derived contracts, which may
+    // not receive the token address as an argument, or even deploy it themselves.
+    function _setToken(IERC20 token_) internal {
+        require(address(_token) == address(0), "ERC20Migrator: token already set");
+        require(address(token_) != address(0), "ERC20Migrator: token is the zero address");
+
+        _token = token_;
+    }
+
+    function acceptRelayedCall(
+        address,
+        address from,
+        bytes calldata,
+        uint256,
+        uint256,
+        uint256,
+        uint256,
+        bytes calldata,
+        uint256 maxPossibleCharge
+    )
+        external
+        view
+        returns (uint256, bytes memory)
+    {
+        uint256 maxTokenCharge = _getEquivalentTokens(maxPossibleCharge);
+
+        if (_token.balanceOf(from) < maxTokenCharge) {
+            return (_declineRelayedCall(uint256(GSNRecipientERC20ChargeErrorCodes.INSUFFICIENT_BALANCE)), "");
+        } else if (_token.allowance(from, address(this)) < maxTokenCharge) {
+            return (_declineRelayedCall(uint256(GSNRecipientERC20ChargeErrorCodes.INSUFFICIENT_ALLOWANCE)), "");
+        }
+
+        return (_acceptRelayedCall(), abi.encode(from, maxTokenCharge));
+    }
+
+    function preRelayedCall(bytes calldata context) external returns (bytes32) {
+        (address from, uint256 maxTokenCharge) = abi.decode(context, (address, uint256));
+
+        // The maximum token charge is pre-charged from the user
+        _token.safeTransferFrom(from, address(this), maxTokenCharge);
+    }
+
+    function postRelayedCall(bytes calldata context, bool, uint256 actualCharge, bytes32) external {
+        (address from, uint256 maxTokenCharge) = abi.decode(context, (address, uint256));
+
+        // After the relayed call has been executed and the actual charge estimated, the excess pre-charge is returned
+        _token.safeTransfer(from, maxTokenCharge.sub(actualCharge));
+    }
+
+    /**
+     * @dev Converts an amount in wei to the equivalent number of tokens. This fucntion must be implemented by derived
+     * contracts by specifying an exchange rate, which may e.g. be consulted from an oracle.
+     */
+    function _getEquivalentTokens(uint256 weiAmount) internal view returns (uint256);
+}