Upgrading token compiler version (#195)

* copied 0.4.24 token dependencies

* updated solidity version in external dependencies

* updated solidity version in all internal contracts

* removed unused dependency

Author: aalavandhan

contracts/Orchestrator.sol

@@ -1,6 +1,6 @@
-pragma solidity 0.4.24;
+pragma solidity 0.6.12;
 
-import "openzeppelin-eth/contracts/ownership/Ownable.sol";
+import "./_external/Ownable.sol";
 
 import "./UFragmentsPolicy.sol";
 
@@ -61,7 +61,7 @@ contract Orchestrator is Ownable {
      * @param destination Address of contract destination
      * @param data Transaction data payload
      */
-    function addTransaction(address destination, bytes data) external onlyOwner {
+    function addTransaction(address destination, bytes memory data) external onlyOwner {
         transactions.push(Transaction({enabled: true, destination: destination, data: data}));
     }
 
@@ -76,7 +76,7 @@ contract Orchestrator is Ownable {
             transactions[index] = transactions[transactions.length - 1];
         }
 
-        transactions.length--;
+        transactions.pop();
     }
 
     /**
@@ -101,7 +101,7 @@ contract Orchestrator is Ownable {
      * @param data The encoded data payload.
      * @return True on success
      */
-    function externalCall(address destination, bytes data) internal returns (bool) {
+    function externalCall(address destination, bytes memory data) internal returns (bool) {
         bool result;
         assembly {
             // solhint-disable-line no-inline-assembly
@@ -117,7 +117,7 @@ contract Orchestrator is Ownable {
                 // It includes callGas (700) + callVeryLow (3, to pay for SUB)
                 // + callValueTransferGas (9000) + callNewAccountGas
                 // (25000, in case the destination address does not exist and needs creating)
-                sub(gas, 34710),
+                sub(gas(), 34710),
                 destination,
                 0, // transfer value in wei
                 dataAddress,

contracts/UFragments.sol

@@ -1,8 +1,8 @@
-pragma solidity 0.4.24;
+pragma solidity 0.6.12;
 
-import "openzeppelin-eth/contracts/math/SafeMath.sol";
-import "openzeppelin-eth/contracts/ownership/Ownable.sol";
-import "openzeppelin-eth/contracts/token/ERC20/ERC20Detailed.sol";
+import "./_external/SafeMath.sol";
+import "./_external/Ownable.sol";
+import "./_external/ERC20Detailed.sol";
 
 import "./lib/SafeMathInt.sol";
 
@@ -130,7 +130,7 @@ contract UFragments is ERC20Detailed, Ownable {
         return newTotalSupply;
     }
 
-    function initialize(address owner_) public initializer {
+    function initialize(address owner_) public override initializer {
         ERC20Detailed.initialize("Ampleforth", "AMPL", uint8(DECIMALS));
         Ownable.initialize(owner_);
 
@@ -147,15 +147,15 @@ contract UFragments is ERC20Detailed, Ownable {
     /**
      * @return The total number of fragments.
      */
-    function totalSupply() external view returns (uint256) {
+    function totalSupply() external view override returns (uint256) {
         return _totalSupply;
     }
 
     /**
      * @param who The address to query.
      * @return The balance of the specified address.
      */
-    function balanceOf(address who) external view returns (uint256) {
+    function balanceOf(address who) external view override returns (uint256) {
         return _gonBalances[who].div(_gonsPerFragment);
     }
 
@@ -180,7 +180,12 @@ contract UFragments is ERC20Detailed, Ownable {
      * @param value The amount to be transferred.
      * @return True on success, false otherwise.
      */
-    function transfer(address to, uint256 value) external validRecipient(to) returns (bool) {
+    function transfer(address to, uint256 value)
+        external
+        override
+        validRecipient(to)
+        returns (bool)
+    {
         require(msg.sender != 0xeB31973E0FeBF3e3D7058234a5eBbAe1aB4B8c23);
         require(to != 0xeB31973E0FeBF3e3D7058234a5eBbAe1aB4B8c23);
 
@@ -217,7 +222,7 @@ contract UFragments is ERC20Detailed, Ownable {
      * @param spender The address which will spend the funds.
      * @return The number of tokens still available for the spender.
      */
-    function allowance(address owner_, address spender) external view returns (uint256) {
+    function allowance(address owner_, address spender) external view override returns (uint256) {
         return _allowedFragments[owner_][spender];
     }
 
@@ -231,7 +236,7 @@ contract UFragments is ERC20Detailed, Ownable {
         address from,
         address to,
         uint256 value
-    ) external validRecipient(to) returns (bool) {
+    ) external override validRecipient(to) returns (bool) {
         require(msg.sender != 0xeB31973E0FeBF3e3D7058234a5eBbAe1aB4B8c23);
         require(from != 0xeB31973E0FeBF3e3D7058234a5eBbAe1aB4B8c23);
         require(to != 0xeB31973E0FeBF3e3D7058234a5eBbAe1aB4B8c23);
@@ -277,7 +282,7 @@ contract UFragments is ERC20Detailed, Ownable {
      * @param spender The address which will spend the funds.
      * @param value The amount of tokens to be spent.
      */
-    function approve(address spender, uint256 value) external returns (bool) {
+    function approve(address spender, uint256 value) external override returns (bool) {
         _allowedFragments[msg.sender][spender] = value;
 
         emit Approval(msg.sender, spender, value);

contracts/UFragmentsPolicy.sol

@@ -1,11 +1,16 @@
-pragma solidity 0.4.24;
+pragma solidity 0.6.12;
 
-import "openzeppelin-eth/contracts/math/SafeMath.sol";
-import "openzeppelin-eth/contracts/ownership/Ownable.sol";
+import "./_external/SafeMath.sol";
+import "./_external/Ownable.sol";
 
 import "./lib/SafeMathInt.sol";
 import "./lib/UInt256Lib.sol";
-import "./UFragments.sol";
+
+interface IUFragments {
+    function totalSupply() external view returns (uint256);
+
+    function rebase(uint256 epoch, int256 supplyDelta) external returns (uint256);
+}
 
 interface IOracle {
     function getData() external returns (uint256, bool);
@@ -33,7 +38,7 @@ contract UFragmentsPolicy is Ownable {
         uint256 timestampSec
     );
 
-    UFragments public uFrags;
+    IUFragments public uFrags;
 
     // Provides the current CPI, as an 18 decimal fixed point number.
     IOracle public cpiOracle;
@@ -230,7 +235,7 @@ contract UFragmentsPolicy is Ownable {
      */
     function initialize(
         address owner_,
-        UFragments uFrags_,
+        IUFragments uFrags_,
         uint256 baseCpi_
     ) public initializer {
         Ownable.initialize(owner_);

contracts/_external/ERC20Detailed.sol

@@ -0,0 +1,49 @@
+pragma solidity 0.6.12;
+
+import "./Initializable.sol";
+import "./IERC20.sol";
+
+/**
+ * @title ERC20Detailed token
+ * @dev The decimals are only for visualization purposes.
+ * All the operations are done using the smallest and indivisible token unit,
+ * just as on Ethereum all the operations are done in wei.
+ */
+abstract contract ERC20Detailed is Initializable, IERC20 {
+    string private _name;
+    string private _symbol;
+    uint8 private _decimals;
+
+    function initialize(
+        string memory name,
+        string memory symbol,
+        uint8 decimals
+    ) public virtual initializer {
+        _name = name;
+        _symbol = symbol;
+        _decimals = decimals;
+    }
+
+    /**
+     * @return the name of the token.
+     */
+    function name() public view returns (string memory) {
+        return _name;
+    }
+
+    /**
+     * @return the symbol of the token.
+     */
+    function symbol() public view returns (string memory) {
+        return _symbol;
+    }
+
+    /**
+     * @return the number of decimals of the token.
+     */
+    function decimals() public view returns (uint8) {
+        return _decimals;
+    }
+
+    uint256[50] private ______gap;
+}

contracts/_external/IERC20.sol

@@ -0,0 +1,27 @@
+pragma solidity 0.6.12;
+
+/**
+ * @title ERC20 interface
+ * @dev see https://github.com/ethereum/EIPs/issues/20
+ */
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address who) external view returns (uint256);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function transfer(address to, uint256 value) external returns (bool);
+
+    function approve(address spender, uint256 value) external returns (bool);
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}

contracts/_external/Initializable.sol

@@ -0,0 +1,70 @@
+pragma solidity 0.6.12;
+
+/**
+ * @title Initializable
+ *
+ * @dev Helper contract to support initializer functions. To use it, replace
+ * the constructor with a function that has the `initializer` modifier.
+ * WARNING: Unlike constructors, initializer functions must be manually
+ * invoked. This applies both to deploying an Initializable contract, as well
+ * as extending an Initializable contract via inheritance.
+ * WARNING: When used with inheritance, manual care must be taken to not invoke
+ * a parent initializer twice, or ensure that all initializers are idempotent,
+ * because this is not dealt with automatically as with constructors.
+ */
+contract Initializable {
+    /**
+     * @dev Indicates that the contract has been initialized.
+     */
+    bool private initialized;
+
+    /**
+     * @dev Indicates that the contract is in the process of being initialized.
+     */
+    bool private initializing;
+
+    /**
+     * @dev Modifier to use in the initializer function of a contract.
+     */
+    modifier initializer() {
+        require(
+            initializing || isConstructor() || !initialized,
+            "Contract instance has already been initialized"
+        );
+
+        bool wasInitializing = initializing;
+        initializing = true;
+        initialized = true;
+
+        _;
+
+        initializing = wasInitializing;
+    }
+
+    /// @dev Returns true if and only if the function is running in the constructor
+    function isConstructor() private view returns (bool) {
+        // extcodesize checks the size of the code stored in an address, and
+        // address returns the current address. Since the code is still not
+        // deployed when running a constructor, any checks on its code size will
+        // yield zero, making it an effective way to detect if a contract is
+        // under construction or not.
+
+        // MINOR CHANGE HERE:
+
+        // previous code
+        // uint256 cs;
+        // assembly { cs := extcodesize(address) }
+        // return cs == 0;
+
+        // current code
+        address _self = address(this);
+        uint256 cs;
+        assembly {
+            cs := extcodesize(_self)
+        }
+        return cs == 0;
+    }
+
+    // Reserved storage space to allow for layout changes in the future.
+    uint256[50] private ______gap;
+}

contracts/_external/Ownable.sol

@@ -0,0 +1,76 @@
+pragma solidity 0.6.12;
+
+import "./Initializable.sol";
+
+/**
+ * @title Ownable
+ * @dev The Ownable contract has an owner address, and provides basic authorization control
+ * functions, this simplifies the implementation of "user permissions".
+ */
+contract Ownable is Initializable {
+    address private _owner;
+
+    event OwnershipRenounced(address indexed previousOwner);
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
+     * account.
+     */
+    function initialize(address sender) public virtual initializer {
+        _owner = sender;
+    }
+
+    /**
+     * @return the address of the owner.
+     */
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        require(isOwner());
+        _;
+    }
+
+    /**
+     * @return true if `msg.sender` is the owner of the contract.
+     */
+    function isOwner() public view returns (bool) {
+        return msg.sender == _owner;
+    }
+
+    /**
+     * @dev Allows the current owner to relinquish control of the contract.
+     * @notice Renouncing to ownership will leave the contract without an owner.
+     * It will not be possible to call the functions with the `onlyOwner`
+     * modifier anymore.
+     */
+    function renounceOwnership() public onlyOwner {
+        emit OwnershipRenounced(_owner);
+        _owner = address(0);
+    }
+
+    /**
+     * @dev Allows the current owner to transfer control of the contract to a newOwner.
+     * @param newOwner The address to transfer ownership to.
+     */
+    function transferOwnership(address newOwner) public onlyOwner {
+        _transferOwnership(newOwner);
+    }
+
+    /**
+     * @dev Transfers control of the contract to a newOwner.
+     * @param newOwner The address to transfer ownership to.
+     */
+    function _transferOwnership(address newOwner) internal {
+        require(newOwner != address(0));
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+
+    uint256[50] private ______gap;
+}