Release v2.1.0 solc 0.5.x (#1568)

* Now compiling in a separate directory using truffle 5.

* Ported to 0.5.1, now compiling using 0.5.1.

* test now also compiles using the truffle 5 hack.

* Downgraded to 0.5.0.

* Sorted scripts.

* Cleaned up the compile script a bit.

.gitignore

@@ -37,3 +37,6 @@ build/
 
 # truffle
 .node-xmlhttprequest-*
+
+# Temporary directory for 0.5.x compilation
+solc-0.5

contracts/access/Roles.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title Roles

contracts/access/roles/CapperRole.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Roles.sol";
 

contracts/access/roles/MinterRole.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Roles.sol";
 

contracts/access/roles/PauserRole.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Roles.sol";
 

contracts/access/roles/SignerRole.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Roles.sol";
 

contracts/access/roles/WhitelistedRole.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Roles.sol";
 import "./WhitelisterRole.sol";

contracts/access/roles/WhitelisterRole.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Roles.sol";
 

contracts/crowdsale/Crowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../math/SafeMath.sol";
@@ -25,7 +25,7 @@ contract Crowdsale is ReentrancyGuard {
     IERC20 private _token;
 
     // Address where funds are collected
-    address private _wallet;
+    address payable private _wallet;
 
     // How many token units a buyer gets per wei.
     // The rate is the conversion between wei and the smallest and indivisible token unit.
@@ -53,10 +53,10 @@ contract Crowdsale is ReentrancyGuard {
      * @param wallet Address where collected funds will be forwarded to
      * @param token Address of the token being sold
      */
-    constructor (uint256 rate, address wallet, IERC20 token) public {
+    constructor (uint256 rate, address payable wallet, IERC20 token) public {
         require(rate > 0);
         require(wallet != address(0));
-        require(token != address(0));
+        require(address(token) != address(0));
 
         _rate = rate;
         _wallet = wallet;
@@ -87,7 +87,7 @@ contract Crowdsale is ReentrancyGuard {
     /**
      * @return the address where funds are collected.
      */
-    function wallet() public view returns (address) {
+    function wallet() public view returns (address payable) {
         return _wallet;
     }
 

contracts/crowdsale/distribution/FinalizableCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../math/SafeMath.sol";
 import "../validation/TimedCrowdsale.sol";

contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../validation/TimedCrowdsale.sol";
 import "../../math/SafeMath.sol";

contracts/crowdsale/distribution/RefundableCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../math/SafeMath.sol";
 import "./FinalizableCrowdsale.sol";
@@ -44,7 +44,7 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
      * @dev Investors can claim refunds here if crowdsale is unsuccessful
      * @param refundee Whose refund will be claimed.
      */
-    function claimRefund(address refundee) public {
+    function claimRefund(address payable refundee) public {
         require(finalized());
         require(!goalReached());
 

contracts/crowdsale/distribution/RefundablePostDeliveryCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./RefundableCrowdsale.sol";
 import "./PostDeliveryCrowdsale.sol";

contracts/crowdsale/emission/AllowanceCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Crowdsale.sol";
 import "../../token/ERC20/IERC20.sol";
@@ -37,7 +37,7 @@ contract AllowanceCrowdsale is Crowdsale {
      * @return Amount of tokens left in the allowance
      */
     function remainingTokens() public view returns (uint256) {
-        return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, this));
+        return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
     }
 
     /**

contracts/crowdsale/emission/MintedCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../Crowdsale.sol";
 import "../../token/ERC20/ERC20Mintable.sol";

contracts/crowdsale/price/IncreasingPriceCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../validation/TimedCrowdsale.sol";
 import "../../math/SafeMath.sol";

contracts/crowdsale/validation/CappedCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";

contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";

contracts/crowdsale/validation/PausableCrowdsale.sol

-pragma solidity ^0.4.18;
+pragma solidity ^0.5.0;
 
 import "../Crowdsale.sol";
 import "../../lifecycle/Pausable.sol";

contracts/crowdsale/validation/TimedCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";

contracts/crowdsale/validation/WhitelistCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 import "../Crowdsale.sol";
 import "../../access/roles/WhitelistedRole.sol";
 

contracts/cryptography/ECDSA.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title Elliptic curve signature operations
@@ -13,7 +13,7 @@ library ECDSA {
      * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
      * @param signature bytes signature, the signature is generated using web3.eth.sign()
      */
-    function recover(bytes32 hash, bytes signature) internal pure returns (address) {
+    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
         bytes32 r;
         bytes32 s;
         uint8 v;

contracts/cryptography/MerkleProof.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title MerkleProof
@@ -13,7 +13,7 @@ library MerkleProof {
      * @param root Merkle root
      * @param leaf Leaf of Merkle tree
      */
-    function verify(bytes32[] proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
+    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
         bytes32 computedHash = leaf;
 
         for (uint256 i = 0; i < proof.length; i++) {

contracts/drafts/Counter.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title Counter

contracts/drafts/ERC1046/TokenMetadata.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../token/ERC20/IERC20.sol";
 
@@ -9,17 +9,17 @@ import "../../token/ERC20/IERC20.sol";
  * @dev TODO - update https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/token/ERC721/IERC721.sol#L17 when 1046 is finalized
  */
 contract ERC20TokenMetadata is IERC20 {
-    function tokenURI() external view returns (string);
+    function tokenURI() external view returns (string memory);
 }
 
 contract ERC20WithMetadata is ERC20TokenMetadata {
     string private _tokenURI;
 
-    constructor (string tokenURI) public {
+    constructor (string memory tokenURI) public {
         _tokenURI = tokenURI;
     }
 
-    function tokenURI() external view returns (string) {
+    function tokenURI() external view returns (string memory) {
         return _tokenURI;
     }
 }

contracts/drafts/ERC20Migrator.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../token/ERC20/ERC20Mintable.sol";
@@ -44,7 +44,7 @@ contract ERC20Migrator {
      * @param legacyToken address of the old token contract
      */
     constructor (IERC20 legacyToken) public {
-        require(legacyToken != address(0));
+        require(address(legacyToken) != address(0));
         _legacyToken = legacyToken;
     }
 
@@ -68,9 +68,9 @@ contract ERC20Migrator {
      * @param newToken the token that will be minted
      */
     function beginMigration(ERC20Mintable newToken) public {
-        require(_newToken == address(0));
-        require(newToken != address(0));
-        require(newToken.isMinter(this));
+        require(address(_newToken) == address(0));
+        require(address(newToken) != address(0));
+        require(newToken.isMinter(address(this)));
 
         _newToken = newToken;
     }
@@ -82,7 +82,7 @@ contract ERC20Migrator {
      * @param amount amount of tokens to be migrated
      */
     function migrate(address account, uint256 amount) public {
-        _legacyToken.safeTransferFrom(account, this, amount);
+        _legacyToken.safeTransferFrom(account, address(this), amount);
         _newToken.mint(account, amount);
     }
 
@@ -93,7 +93,7 @@ contract ERC20Migrator {
      */
     function migrateAll(address account) public {
         uint256 balance = _legacyToken.balanceOf(account);
-        uint256 allowance = _legacyToken.allowance(account, this);
+        uint256 allowance = _legacyToken.allowance(account, address(this));
         uint256 amount = Math.min(balance, allowance);
         migrate(account, amount);
     }

contracts/drafts/SignatureBouncer.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/SignerRole.sol";
 import "../cryptography/ECDSA.sol";
@@ -48,7 +48,7 @@ contract SignatureBouncer is SignerRole {
     /**
      * @dev requires that a valid signature of a signer was provided
      */
-    modifier onlyValidSignature(bytes signature) {
+    modifier onlyValidSignature(bytes memory signature) {
         require(_isValidSignature(msg.sender, signature));
         _;
     }
@@ -56,7 +56,7 @@ contract SignatureBouncer is SignerRole {
     /**
      * @dev requires that a valid signature with a specifed method of a signer was provided
      */
-    modifier onlyValidSignatureAndMethod(bytes signature) {
+    modifier onlyValidSignatureAndMethod(bytes memory signature) {
         require(_isValidSignatureAndMethod(msg.sender, signature));
         _;
     }
@@ -64,7 +64,7 @@ contract SignatureBouncer is SignerRole {
     /**
      * @dev requires that a valid signature with a specifed method and params of a signer was provided
      */
-    modifier onlyValidSignatureAndData(bytes signature) {
+    modifier onlyValidSignatureAndData(bytes memory signature) {
         require(_isValidSignatureAndData(msg.sender, signature));
         _;
     }
@@ -73,7 +73,7 @@ contract SignatureBouncer is SignerRole {
      * @dev is the signature of `this + sender` from a signer?
      * @return bool
      */
-    function _isValidSignature(address account, bytes signature) internal view returns (bool) {
+    function _isValidSignature(address account, bytes memory signature) internal view returns (bool) {
         return _isValidDataHash(keccak256(abi.encodePacked(address(this), account)), signature);
     }
 
@@ -81,7 +81,7 @@ contract SignatureBouncer is SignerRole {
      * @dev is the signature of `this + sender + methodId` from a signer?
      * @return bool
      */
-    function _isValidSignatureAndMethod(address account, bytes signature) internal view returns (bool) {
+    function _isValidSignatureAndMethod(address account, bytes memory signature) internal view returns (bool) {
         bytes memory data = new bytes(_METHOD_ID_SIZE);
         for (uint i = 0; i < data.length; i++) {
             data[i] = msg.data[i];
@@ -94,7 +94,7 @@ contract SignatureBouncer is SignerRole {
         * @notice the signature parameter of the method being validated must be the "last" parameter
         * @return bool
         */
-    function _isValidSignatureAndData(address account, bytes signature) internal view returns (bool) {
+    function _isValidSignatureAndData(address account, bytes memory signature) internal view returns (bool) {
         require(msg.data.length > _SIGNATURE_SIZE);
 
         bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
@@ -110,7 +110,7 @@ contract SignatureBouncer is SignerRole {
      * and then recover the signature and check it against the signer role
      * @return bool
      */
-    function _isValidDataHash(bytes32 hash, bytes signature) internal view returns (bool) {
+    function _isValidDataHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
         address signer = hash.toEthSignedMessageHash().recover(signature);
 
         return signer != address(0) && isSigner(signer);

contracts/drafts/TokenVesting.sol

 /* solium-disable security/no-block-members */
 
-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/SafeERC20.sol";
 import "../ownership/Ownable.sol";
@@ -112,11 +112,11 @@ contract TokenVesting is Ownable {
 
         require(unreleased > 0);
 
-        _released[token] = _released[token].add(unreleased);
+        _released[address(token)] = _released[address(token)].add(unreleased);
 
         token.safeTransfer(_beneficiary, unreleased);
 
-        emit TokensReleased(token, unreleased);
+        emit TokensReleased(address(token), unreleased);
     }
 
     /**
@@ -126,18 +126,18 @@ contract TokenVesting is Ownable {
      */
     function revoke(IERC20 token) public onlyOwner {
         require(_revocable);
-        require(!_revoked[token]);
+        require(!_revoked[address(token)]);
 
         uint256 balance = token.balanceOf(address(this));
 
         uint256 unreleased = _releasableAmount(token);
         uint256 refund = balance.sub(unreleased);
 
-        _revoked[token] = true;
+        _revoked[address(token)] = true;
 
         token.safeTransfer(owner(), refund);
 
-        emit TokenVestingRevoked(token);
+        emit TokenVestingRevoked(address(token));
     }
 
     /**
@@ -145,7 +145,7 @@ contract TokenVesting is Ownable {
      * @param token ERC20 token which is being vested
      */
     function _releasableAmount(IERC20 token) private view returns (uint256) {
-        return _vestedAmount(token).sub(_released[token]);
+        return _vestedAmount(token).sub(_released[address(token)]);
     }
 
     /**
@@ -154,11 +154,11 @@ contract TokenVesting is Ownable {
      */
     function _vestedAmount(IERC20 token) private view returns (uint256) {
         uint256 currentBalance = token.balanceOf(address(this));
-        uint256 totalBalance = currentBalance.add(_released[token]);
+        uint256 totalBalance = currentBalance.add(_released[address(token)]);
 
         if (block.timestamp < _cliff) {
             return 0;
-        } else if (block.timestamp >= _start.add(_duration) || _revoked[token]) {
+        } else if (block.timestamp >= _start.add(_duration) || _revoked[address(token)]) {
             return totalBalance;
         } else {
             return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);

contracts/examples/SampleCrowdsale.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../crowdsale/validation/CappedCrowdsale.sol";
 import "../crowdsale/distribution/RefundableCrowdsale.sol";
@@ -38,7 +38,7 @@ contract SampleCrowdsale is CappedCrowdsale, RefundableCrowdsale, MintedCrowdsal
         uint256 openingTime,
         uint256 closingTime,
         uint256 rate,
-        address wallet,
+        address payable wallet,
         uint256 cap,
         ERC20Mintable token,
         uint256 goal

contracts/examples/SimpleToken.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20.sol";
 import "../token/ERC20/ERC20Detailed.sol";
@@ -10,12 +10,13 @@ import "../token/ERC20/ERC20Detailed.sol";
  * `ERC20` functions.
  */
 contract SimpleToken is ERC20, ERC20Detailed {
-    uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(decimals()));
+    uint8 public constant DECIMALS = 18;
+    uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(DECIMALS));
 
     /**
      * @dev Constructor that gives msg.sender all of existing tokens.
      */
-    constructor () public ERC20Detailed("SimpleToken", "SIM", 18) {
+    constructor () public ERC20Detailed("SimpleToken", "SIM", DECIMALS) {
         _mint(msg.sender, INITIAL_SUPPLY);
     }
 }

contracts/introspection/ERC165.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./IERC165.sol";
 

contracts/introspection/ERC165Checker.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title ERC165Checker
@@ -49,7 +49,7 @@ library ERC165Checker {
      * interfaceIds list, false otherwise
      * @dev Interface identification is specified in ERC-165.
      */
-    function _supportsAllInterfaces(address account, bytes4[] interfaceIds) internal view returns (bool) {
+    function _supportsAllInterfaces(address account, bytes4[] memory interfaceIds) internal view returns (bool) {
         // query support of ERC165 itself
         if (!_supportsERC165(account)) {
             return false;

contracts/introspection/IERC165.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title IERC165

contracts/lifecycle/Pausable.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/PauserRole.sol";
 

contracts/math/Math.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title Math

contracts/math/SafeMath.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title SafeMath

contracts/mocks/Acknowledger.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 contract Acknowledger {
     event AcknowledgeFoo(uint256 a);

contracts/mocks/AddressImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../utils/Address.sol";
 

contracts/mocks/AllowanceCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/emission/AllowanceCrowdsale.sol";
 
 contract AllowanceCrowdsaleImpl is AllowanceCrowdsale {
-    constructor (uint256 rate, address wallet, IERC20 token, address tokenWallet)
+    constructor (uint256 rate, address payable wallet, IERC20 token, address tokenWallet)
         public
         Crowdsale(rate, wallet, token)
         AllowanceCrowdsale(tokenWallet)

contracts/mocks/ArraysImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../utils/Arrays.sol";
 
@@ -7,7 +7,7 @@ contract ArraysImpl {
 
     uint256[] private array;
 
-    constructor (uint256[] _array) public {
+    constructor (uint256[] memory _array) public {
         array = _array;
     }
 

contracts/mocks/CappedCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/CappedCrowdsale.sol";
 
 contract CappedCrowdsaleImpl is CappedCrowdsale {
-    constructor (uint256 rate, address wallet, IERC20 token, uint256 cap)
+    constructor (uint256 rate, address payable wallet, IERC20 token, uint256 cap)
         public
         Crowdsale(rate, wallet, token)
         CappedCrowdsale(cap)

contracts/mocks/CapperRoleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/CapperRole.sol";
 

contracts/mocks/ConditionalEscrowMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../payment/escrow/ConditionalEscrow.sol";
 

contracts/mocks/CounterImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../drafts/Counter.sol";
 
@@ -10,7 +10,7 @@ contract CounterImpl {
     // use whatever key you want to track your counters
     mapping(string => Counter.Counter) private _counters;
 
-    function doThing(string key) public returns (uint256) {
+    function doThing(string memory key) public returns (uint256) {
         theId = _counters[key].next();
         return theId;
     }

contracts/mocks/CrowdsaleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../crowdsale/Crowdsale.sol";
 
 contract CrowdsaleMock is Crowdsale {
-    constructor (uint256 rate, address wallet, IERC20 token) public Crowdsale(rate, wallet, token) {}
+    constructor (uint256 rate, address payable wallet, IERC20 token) public Crowdsale(rate, wallet, token) {}
 }

contracts/mocks/DetailedERC20Mock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20.sol";
 import "../token/ERC20/ERC20Detailed.sol";
 
 contract ERC20DetailedMock is ERC20, ERC20Detailed {
-    constructor (string name, string symbol, uint8 decimals) ERC20Detailed(name, symbol, decimals) public {}
+    constructor (string memory name, string memory symbol, uint8 decimals) ERC20Detailed(name, symbol, decimals) public {}
 }

contracts/mocks/ECDSAMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../cryptography/ECDSA.sol";
 
 contract ECDSAMock {
     using ECDSA for bytes32;
 
-    function recover(bytes32 hash, bytes signature) public pure returns (address) {
+    function recover(bytes32 hash, bytes memory signature) public pure returns (address) {
         return hash.recover(signature);
     }
 

contracts/mocks/ERC165/ERC165InterfacesSupported.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../introspection/IERC165.sol";
 
@@ -47,7 +47,7 @@ contract SupportsInterfaceWithLookupMock is IERC165 {
 }
 
 contract ERC165InterfacesSupported is SupportsInterfaceWithLookupMock {
-    constructor (bytes4[] interfaceIds) public {
+    constructor (bytes4[] memory interfaceIds) public {
         for (uint256 i = 0; i < interfaceIds.length; i++) {
             _registerInterface(interfaceIds[i]);
         }

contracts/mocks/ERC165/ERC165NotSupported.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 contract ERC165NotSupported {}

contracts/mocks/ERC165CheckerMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../introspection/ERC165Checker.sol";
 
@@ -13,7 +13,7 @@ contract ERC165CheckerMock {
         return account._supportsInterface(interfaceId);
     }
 
-    function supportsAllInterfaces(address account, bytes4[] interfaceIds) public view returns (bool) {
+    function supportsAllInterfaces(address account, bytes4[] memory interfaceIds) public view returns (bool) {
         return account._supportsAllInterfaces(interfaceIds);
     }
 }

contracts/mocks/ERC165Mock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../introspection/ERC165.sol";
 

contracts/mocks/ERC20BurnableMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20Burnable.sol";
 

contracts/mocks/ERC20MintableMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20Mintable.sol";
 import "./MinterRoleMock.sol";

contracts/mocks/ERC20Mock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20.sol";
 

contracts/mocks/ERC20PausableMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20Pausable.sol";
 import "./PauserRoleMock.sol";

contracts/mocks/ERC20WithMetadataMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20.sol";
 import "../drafts/ERC1046/TokenMetadata.sol";
 
 contract ERC20WithMetadataMock is ERC20, ERC20WithMetadata {
-    constructor (string tokenURI) public ERC20WithMetadata(tokenURI) {}
+    constructor (string memory tokenURI) public ERC20WithMetadata(tokenURI) {}
 }

contracts/mocks/ERC721FullMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC721/ERC721Full.sol";
 import "../token/ERC721/ERC721Mintable.sol";
@@ -11,7 +11,7 @@ import "../token/ERC721/ERC721Burnable.sol";
  * checking token existence, removal of a token from an address
  */
 contract ERC721FullMock is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
-    constructor (string name, string symbol) public ERC721Mintable() ERC721Full(name, symbol) {}
+    constructor (string memory name, string memory symbol) public ERC721Mintable() ERC721Full(name, symbol) {}
 
     function exists(uint256 tokenId) public view returns (bool) {
         return _exists(tokenId);
@@ -21,7 +21,7 @@ contract ERC721FullMock is ERC721Full, ERC721Mintable, ERC721MetadataMintable, E
         return _tokensOfOwner(owner);
     }
 
-    function setTokenURI(uint256 tokenId, string uri) public {
+    function setTokenURI(uint256 tokenId, string memory uri) public {
         _setTokenURI(tokenId, uri);
     }
 }

contracts/mocks/ERC721MintableBurnableImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC721/ERC721Full.sol";
 import "../token/ERC721/ERC721Mintable.sol";

contracts/mocks/ERC721Mock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC721/ERC721.sol";
 

contracts/mocks/ERC721PausableMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC721/ERC721Pausable.sol";
 import "./PauserRoleMock.sol";

contracts/mocks/ERC721ReceiverMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC721/IERC721Receiver.sol";
 
@@ -13,7 +13,7 @@ contract ERC721ReceiverMock is IERC721Receiver {
         _reverts = reverts;
     }
 
-    function onERC721Received(address operator, address from, uint256 tokenId, bytes data) public returns (bytes4) {
+    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data) public returns (bytes4) {
         require(!_reverts);
         emit Received(operator, from, tokenId, data, gasleft());
         return _retval;

contracts/mocks/EventEmitter.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 contract EventEmitter {
     event Argumentless();
@@ -11,7 +11,7 @@ contract EventEmitter {
     event String(string value);
     event LongUintBooleanString(uint256 uintValue, bool booleanValue, string stringValue);
 
-    constructor (uint8 uintValue, bool booleanValue, string stringValue) public {
+    constructor (uint8 uintValue, bool booleanValue, string memory stringValue) public {
         emit ShortUint(uintValue);
         emit Boolean(booleanValue);
         emit String(stringValue);
@@ -45,11 +45,11 @@ contract EventEmitter {
         emit Boolean(value);
     }
 
-    function emitString(string value) public {
+    function emitString(string memory value) public {
         emit String(value);
     }
 
-    function emitLongUintBooleanString(uint256 uintValue, bool booleanValue, string stringValue) public {
+    function emitLongUintBooleanString(uint256 uintValue, bool booleanValue, string memory stringValue) public {
         emit LongUintBooleanString(uintValue, booleanValue, stringValue);
     }
 
@@ -58,7 +58,7 @@ contract EventEmitter {
         emit Boolean(boolValue);
     }
 
-    function emitStringAndEmitIndirectly(string value, IndirectEventEmitter emitter) public {
+    function emitStringAndEmitIndirectly(string memory value, IndirectEventEmitter emitter) public {
         emit String(value);
         emitter.emitStringIndirectly(value);
     }
@@ -67,7 +67,7 @@ contract EventEmitter {
 contract IndirectEventEmitter {
     event IndirectString(string value);
 
-    function emitStringIndirectly(string value) public {
+    function emitStringIndirectly(string memory value) public {
         emit IndirectString(value);
     }
 }

contracts/mocks/Failer.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 contract Failer {
     uint256[] private array;

contracts/mocks/FinalizableCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/FinalizableCrowdsale.sol";
 
 contract FinalizableCrowdsaleImpl is FinalizableCrowdsale {
 
-    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address wallet, IERC20 token)
+    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address payable wallet, IERC20 token)
         public
         Crowdsale(rate, wallet, token)
         TimedCrowdsale(openingTime, closingTime)

contracts/mocks/IncreasingPriceCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../crowdsale/price/IncreasingPriceCrowdsale.sol";
 import "../math/SafeMath.sol";
@@ -7,7 +7,7 @@ contract IncreasingPriceCrowdsaleImpl is IncreasingPriceCrowdsale {
     constructor (
         uint256 openingTime,
         uint256 closingTime,
-        address wallet,
+        address payable wallet,
         IERC20 token,
         uint256 initialRate,
         uint256 finalRate

contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/IndividuallyCappedCrowdsale.sol";
 import "./CapperRoleMock.sol";
 
 contract IndividuallyCappedCrowdsaleImpl is IndividuallyCappedCrowdsale, CapperRoleMock {
-    constructor (uint256 rate, address wallet, IERC20 token) public Crowdsale(rate, wallet, token)
+    constructor (uint256 rate, address payable wallet, IERC20 token) public Crowdsale(rate, wallet, token)
     {}
 }

contracts/mocks/MathMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../math/Math.sol";
 

contracts/mocks/MerkleProofWrapper.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import { MerkleProof } from "../cryptography/MerkleProof.sol";
 
 contract MerkleProofWrapper {
-    function verify(bytes32[] proof, bytes32 root, bytes32 leaf) public pure returns (bool) {
+    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) public pure returns (bool) {
         return MerkleProof.verify(proof, root, leaf);
     }
 }

contracts/mocks/MintedCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20Mintable.sol";
 import "../crowdsale/emission/MintedCrowdsale.sol";
 
 contract MintedCrowdsaleImpl is MintedCrowdsale {
-    constructor (uint256 rate, address wallet, ERC20Mintable token) public Crowdsale(rate, wallet, token) {}
+    constructor (uint256 rate, address payable wallet, ERC20Mintable token) public Crowdsale(rate, wallet, token) {}
 }

contracts/mocks/MinterRoleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/MinterRole.sol";
 

contracts/mocks/OwnableInterfaceId.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../ownership/Ownable.sol";
 

contracts/mocks/OwnableMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../ownership/Ownable.sol";
 

contracts/mocks/PausableCrowdsaleImpl.sol

-pragma solidity ^0.4.18;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20.sol";
 import "../crowdsale/validation/PausableCrowdsale.sol";
 
 contract PausableCrowdsaleImpl is PausableCrowdsale {
-    constructor (uint256 _rate, address _wallet, ERC20 _token) public Crowdsale(_rate, _wallet, _token) {
+    constructor (uint256 _rate, address payable _wallet, ERC20 _token) public Crowdsale(_rate, _wallet, _token) {
     }
 }

contracts/mocks/PausableMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../lifecycle/Pausable.sol";
 import "./PauserRoleMock.sol";

contracts/mocks/PauserRoleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/PauserRole.sol";
 

contracts/mocks/PostDeliveryCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/PostDeliveryCrowdsale.sol";
 
 contract PostDeliveryCrowdsaleImpl is PostDeliveryCrowdsale {
-    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address wallet, IERC20 token)
+    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address payable wallet, IERC20 token)
         public
         TimedCrowdsale(openingTime, closingTime)
         Crowdsale(rate, wallet, token)

contracts/mocks/PullPaymentMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../payment/PullPayment.sol";
 

contracts/mocks/ReentrancyAttack.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 contract ReentrancyAttack {
 
     function callSender(bytes4 data) public {
         // solium-disable-next-line security/no-low-level-calls
-        require(msg.sender.call(abi.encodeWithSelector(data)));
+        (bool success,) = msg.sender.call(abi.encodeWithSelector(data));
+        require(success);
     }
 
 }

contracts/mocks/ReentrancyMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../utils/ReentrancyGuard.sol";
 import "./ReentrancyAttack.sol";
@@ -25,8 +25,8 @@ contract ReentrancyMock is ReentrancyGuard {
         if (n > 0) {
             count();
             // solium-disable-next-line security/no-low-level-calls
-            bool result = address(this).call(abi.encodeWithSignature("countThisRecursive(uint256)", n - 1));
-            require(result == true);
+            (bool success,) = address(this).call(abi.encodeWithSignature("countThisRecursive(uint256)", n - 1));
+            require(success);
         }
     }
 

contracts/mocks/RefundableCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/RefundableCrowdsale.sol";
@@ -8,7 +8,7 @@ contract RefundableCrowdsaleImpl is RefundableCrowdsale {
         uint256 openingTime,
         uint256 closingTime,
         uint256 rate,
-        address wallet,
+        address payable wallet,
         IERC20 token,
         uint256 goal
     )

contracts/mocks/RefundablePostDeliveryCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/RefundablePostDeliveryCrowdsale.sol";
@@ -8,7 +8,7 @@ contract RefundablePostDeliveryCrowdsaleImpl is RefundablePostDeliveryCrowdsale
         uint256 openingTime,
         uint256 closingTime,
         uint256 rate,
-        address wallet,
+        address payable wallet,
         IERC20 token,
         uint256 goal
     )

contracts/mocks/RolesMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/Roles.sol";
 

contracts/mocks/SafeERC20Helper.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../token/ERC20/SafeERC20.sol";
@@ -54,8 +54,8 @@ contract SafeERC20Helper {
     IERC20 private _succeeding;
 
     constructor () public {
-        _failing = IERC20(new ERC20FailingMock());
-        _succeeding = IERC20(new ERC20SucceedingMock());
+        _failing = IERC20(address(new ERC20FailingMock()));
+        _succeeding = IERC20(address(new ERC20SucceedingMock()));
     }
 
     // Using _failing
@@ -103,7 +103,7 @@ contract SafeERC20Helper {
     }
 
     function setAllowance(uint256 allowance_) public {
-        ERC20SucceedingMock(_succeeding).setAllowance(allowance_);
+        ERC20SucceedingMock(address(_succeeding)).setAllowance(allowance_);
     }
 
     function allowance() public view returns (uint256) {

contracts/mocks/SafeMathMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 
 import "../math/SafeMath.sol";

contracts/mocks/SecondaryMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../ownership/Secondary.sol";
 

contracts/mocks/SignatureBouncerMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../drafts/SignatureBouncer.sol";
 import "./SignerRoleMock.sol";
 
 contract SignatureBouncerMock is SignatureBouncer, SignerRoleMock {
-    function checkValidSignature(address account, bytes signature) public view returns (bool) {
+    function checkValidSignature(address account, bytes memory signature) public view returns (bool) {
         return _isValidSignature(account, signature);
     }
 
-    function onlyWithValidSignature(bytes signature) public onlyValidSignature(signature) view {}
+    function onlyWithValidSignature(bytes memory signature) public onlyValidSignature(signature) view {}
 
-    function checkValidSignatureAndMethod(address account, bytes signature) public view returns (bool) {
+    function checkValidSignatureAndMethod(address account, bytes memory signature) public view returns (bool) {
         return _isValidSignatureAndMethod(account, signature);
     }
 
-    function onlyWithValidSignatureAndMethod(bytes signature) public onlyValidSignatureAndMethod(signature) view {}
+    function onlyWithValidSignatureAndMethod(bytes memory signature) public onlyValidSignatureAndMethod(signature) view {}
 
-    function checkValidSignatureAndData(address account, bytes, uint, bytes signature) public view returns (bool) {
+    function checkValidSignatureAndData(address account, bytes memory, uint, bytes memory signature) public view returns (bool) {
         return _isValidSignatureAndData(account, signature);
     }
 
-    function onlyWithValidSignatureAndData(uint, bytes signature) public onlyValidSignatureAndData(signature) view {}
+    function onlyWithValidSignatureAndData(uint, bytes memory signature) public onlyValidSignatureAndData(signature) view {}
 
-    function theWrongMethod(bytes) public pure {}
+    function theWrongMethod(bytes memory) public pure {}
 
     function tooShortMsgData() public onlyValidSignatureAndData("") view {}
 }

contracts/mocks/SignerRoleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/SignerRole.sol";
 

contracts/mocks/TimedCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/TimedCrowdsale.sol";
 
 contract TimedCrowdsaleImpl is TimedCrowdsale {
-    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address wallet, IERC20 token)
+    constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address payable wallet, IERC20 token)
         public
         Crowdsale(rate, wallet, token)
         TimedCrowdsale(openingTime, closingTime)

contracts/mocks/WhitelistCrowdsaleImpl.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/WhitelistCrowdsale.sol";
@@ -6,5 +6,5 @@ import "../crowdsale/Crowdsale.sol";
 
 
 contract WhitelistCrowdsaleImpl is Crowdsale, WhitelistCrowdsale {
-    constructor (uint256 _rate, address _wallet, IERC20 _token) Crowdsale(_rate, _wallet, _token) public {}
+    constructor (uint256 _rate, address payable _wallet, IERC20 _token) Crowdsale(_rate, _wallet, _token) public {}
 }

contracts/mocks/WhitelistedRoleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/WhitelistedRole.sol";
 

contracts/mocks/WhitelisterRoleMock.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../access/roles/WhitelisterRole.sol";
 

contracts/ownership/Ownable.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title Ownable

contracts/ownership/Secondary.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 /**
  * @title Secondary

contracts/payment/PaymentSplitter.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../math/SafeMath.sol";
 
@@ -24,7 +24,7 @@ contract PaymentSplitter {
     /**
      * @dev Constructor
      */
-    constructor (address[] payees, uint256[] shares) public payable {
+    constructor (address[] memory payees, uint256[] memory shares) public payable {
         require(payees.length == shares.length);
         require(payees.length > 0);
 
@@ -79,7 +79,7 @@ contract PaymentSplitter {
      * @dev Release one of the payee's proportional payment.
      * @param account Whose payments will be released.
      */
-    function release(address account) public {
+    function release(address payable account) public {
         require(_shares[account] > 0);
 
         uint256 totalReceived = address(this).balance.add(_totalReleased);

contracts/payment/PullPayment.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./escrow/Escrow.sol";
 
@@ -18,7 +18,7 @@ contract PullPayment {
     * @dev Withdraw accumulated balance.
     * @param payee Whose balance will be withdrawn.
     */
-    function withdrawPayments(address payee) public {
+    function withdrawPayments(address payable payee) public {
         _escrow.withdraw(payee);
     }
 

contracts/payment/escrow/ConditionalEscrow.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./Escrow.sol";
 
@@ -15,7 +15,7 @@ contract ConditionalEscrow is Escrow {
     */
     function withdrawalAllowed(address payee) public view returns (bool);
 
-    function withdraw(address payee) public {
+    function withdraw(address payable payee) public {
         require(withdrawalAllowed(payee));
         super.withdraw(payee);
     }

contracts/payment/escrow/Escrow.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "../../math/SafeMath.sol";
 import "../../ownership/Secondary.sol";
@@ -42,7 +42,7 @@ contract Escrow is Secondary {
     * @dev Withdraw accumulated balance for a payee.
     * @param payee The address whose funds will be withdrawn and transferred to.
     */
-    function withdraw(address payee) public onlyPrimary {
+    function withdraw(address payable payee) public onlyPrimary {
         uint256 payment = _deposits[payee];
 
         _deposits[payee] = 0;

contracts/payment/escrow/RefundEscrow.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./ConditionalEscrow.sol";
 
@@ -20,13 +20,13 @@ contract RefundEscrow is ConditionalEscrow {
     event RefundsEnabled();
 
     State private _state;
-    address private _beneficiary;
+    address payable private _beneficiary;
 
     /**
      * @dev Constructor.
      * @param beneficiary The beneficiary of the deposits.
      */
-    constructor (address beneficiary) public {
+    constructor (address payable beneficiary) public {
         require(beneficiary != address(0));
         _beneficiary = beneficiary;
         _state = State.Active;

contracts/token/ERC20/ERC20.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./IERC20.sol";
 import "../../math/SafeMath.sol";

contracts/token/ERC20/ERC20Burnable.sol

-pragma solidity ^0.4.24;
+pragma solidity ^0.5.0;
 
 import "./ERC20.sol";