Transpile d18e7e7a

buidler/env-artifacts.js

@@ -6,15 +6,18 @@ extendEnvironment(env => {
   env.artifacts = {
     ...artifacts,
     require (name) {
-      try {
-        return artifacts.require(name + 'UpgradeSafeWithInit');
-      } catch (e) {
-        if (BuidlerError.isBuidlerError(e) && e.number === 700) {
-          return artifacts.require(name + 'UpgradeSafe');
-        } else {
-          throw e;
+      for (const suffix of ['UpgradeSafeWithInit', 'UpgradeSafe', '']) {
+        try {
+          return artifacts.require(name + suffix);
+        } catch (e) {
+          if (BuidlerError.isBuidlerError(e) && e.number === 700 && suffix !== '') {
+            continue;
+          } else {
+            throw e;
+          }
         }
       }
+      throw new Error('Unreachable');
     },
   };
 });

contracts/GSN/ContextUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /*
  * @dev Provides information about the current execution context, including the
@@ -13,12 +13,12 @@ import "../Initializable.sol";
  *
  * This contract is only required for intermediate, library-like contracts.
  */
-abstract contract ContextUpgradeSafe is __Initializable {
-    function __Context_init() internal __initializer {
+abstract contract ContextUpgradeSafe is Initializable {
+    function __Context_init() internal initializer {
         __Context_init_unchained();
     }
 
-    function __Context_init_unchained() internal __initializer {
+    function __Context_init_unchained() internal initializer {
     }
     function _msgSender() internal view virtual returns (address payable) {
         return msg.sender;

contracts/GSN/GSNRecipientERC20FeeUpgradeSafe.sol

@@ -7,7 +7,7 @@ import "../math/SafeMathUpgradeSafe.sol";
 import "../access/OwnableUpgradeSafe.sol";
 import "../token/ERC20/SafeERC20UpgradeSafe.sol";
 import "../token/ERC20/ERC20UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev A xref:ROOT:gsn-strategies.adoc#gsn-strategies[GSN strategy] that charges transaction fees in a special purpose ERC20
@@ -18,7 +18,7 @@ import "../Initializable.sol";
  * whose only minter is the recipient, so the strategy must be implemented in a derived contract, making use of the
  * internal {_mint} function.
  */
-contract GSNRecipientERC20FeeUpgradeSafe is __Initializable, GSNRecipientUpgradeSafe {
+contract GSNRecipientERC20FeeUpgradeSafe is Initializable, GSNRecipientUpgradeSafe {
     using SafeERC20UpgradeSafe for __unstable__ERC20OwnedUpgradeSafe;
     using SafeMathUpgradeSafe for uint256;
 
@@ -31,13 +31,13 @@ contract GSNRecipientERC20FeeUpgradeSafe is __Initializable, GSNRecipientUpgrade
     /**
      * @dev The arguments to the constructor are the details that the gas payment token will have: `name` and `symbol`. `decimals` is hard-coded to 18.
      */
-    function __GSNRecipientERC20Fee_init(string memory name, string memory symbol) internal __initializer {
+    function __GSNRecipientERC20Fee_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __GSNRecipient_init_unchained();
         __GSNRecipientERC20Fee_init_unchained(name, symbol);
     }
 
-    function __GSNRecipientERC20Fee_init_unchained(string memory name, string memory symbol) internal __initializer {
+    function __GSNRecipientERC20Fee_init_unchained(string memory name, string memory symbol) internal initializer {
         _token = new __unstable__ERC20OwnedUpgradeSafe();
         _token.initialize(name, symbol);
     }
@@ -122,20 +122,20 @@ contract GSNRecipientERC20FeeUpgradeSafe is __Initializable, GSNRecipientUpgrade
  * outside of this context.
  */
 // solhint-disable-next-line contract-name-camelcase
-contract __unstable__ERC20OwnedUpgradeSafe is __Initializable, ERC20UpgradeSafe, OwnableUpgradeSafe {
-    function initialize(string memory name, string memory symbol) external __initializer {
+contract __unstable__ERC20OwnedUpgradeSafe is Initializable, ERC20UpgradeSafe, OwnableUpgradeSafe {
+    function initialize(string memory name, string memory symbol) external initializer {
         ____unstable__ERC20Owned_init(name, symbol);
     }
     uint256 private constant _UINT256_MAX = 2**256 - 1;
 
-    function ____unstable__ERC20Owned_init(string memory name, string memory symbol) internal __initializer {
+    function ____unstable__ERC20Owned_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __Ownable_init_unchained();
         ____unstable__ERC20Owned_init_unchained(name, symbol);
     }
 
-    function ____unstable__ERC20Owned_init_unchained(string memory name, string memory symbol) internal __initializer { }
+    function ____unstable__ERC20Owned_init_unchained(string memory name, string memory symbol) internal initializer { }
 
     // The owner (GSNRecipientERC20Fee) can mint tokens
     function mint(address account, uint256 amount) public onlyOwner {

contracts/GSN/GSNRecipientSignatureUpgradeSafe.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.6.0;
 
 import "./GSNRecipientUpgradeSafe.sol";
 import "../cryptography/ECDSAUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev A xref:ROOT:gsn-strategies.adoc#gsn-strategies[GSN strategy] that allows relayed transactions through when they are
@@ -12,7 +12,7 @@ import "../Initializable.sol";
  * performs validations off-chain. Note that nothing is charged to the user in this scheme. Thus, the server should make
  * sure to account for this in their economic and threat model.
  */
-contract GSNRecipientSignatureUpgradeSafe is __Initializable, GSNRecipientUpgradeSafe {
+contract GSNRecipientSignatureUpgradeSafe is Initializable, GSNRecipientUpgradeSafe {
     using ECDSAUpgradeSafe for bytes32;
 
     address private _trustedSigner;
@@ -24,13 +24,13 @@ contract GSNRecipientSignatureUpgradeSafe is __Initializable, GSNRecipientUpgrad
     /**
      * @dev Sets the trusted signer that is going to be producing signatures to approve relayed calls.
      */
-    function __GSNRecipientSignature_init(address trustedSigner) internal __initializer {
+    function __GSNRecipientSignature_init(address trustedSigner) internal initializer {
         __Context_init_unchained();
         __GSNRecipient_init_unchained();
         __GSNRecipientSignature_init_unchained(trustedSigner);
     }
 
-    function __GSNRecipientSignature_init_unchained(address trustedSigner) internal __initializer {
+    function __GSNRecipientSignature_init_unchained(address trustedSigner) internal initializer {
         require(trustedSigner != address(0), "GSNRecipientSignature: trusted signer is the zero address");
         _trustedSigner = trustedSigner;
     }

contracts/GSN/GSNRecipientUpgradeSafe.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.6.0;
 import "./IRelayRecipientUpgradeSafe.sol";
 import "./IRelayHubUpgradeSafe.sol";
 import "./ContextUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Base GSN recipient contract: includes the {IRelayRecipient} interface
@@ -18,13 +18,13 @@ import "../Initializable.sol";
  * information on how to use the pre-built {GSNRecipientSignature} and
  * {GSNRecipientERC20Fee}, or how to write your own.
  */
-abstract contract GSNRecipientUpgradeSafe is __Initializable, IRelayRecipientUpgradeSafe, ContextUpgradeSafe {
-    function __GSNRecipient_init() internal __initializer {
+abstract contract GSNRecipientUpgradeSafe is Initializable, IRelayRecipientUpgradeSafe, ContextUpgradeSafe {
+    function __GSNRecipient_init() internal initializer {
         __Context_init_unchained();
         __GSNRecipient_init_unchained();
     }
 
-    function __GSNRecipient_init_unchained() internal __initializer {
+    function __GSNRecipient_init_unchained() internal initializer {
         _relayHub = 0xD216153c06E857cD7f72665E0aF1d7D82172F494;
     }
     // Default RelayHub address, deployed on mainnet and all testnets at the same address

contracts/Initializable.sol

-pragma solidity >=0.4.24 <0.7.0;
-
-
-/**
- * @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 isTopLevelCall = !initializing;
-    if (isTopLevelCall) {
-      initializing = true;
-      initialized = true;
-    }
-
-    _;
-
-    if (isTopLevelCall) {
-      initializing = false;
-    }
-  }
-
-  /// @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.
-    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/access/AccessControlUpgradeSafe.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.6.0;
 import "../utils/EnumerableSetUpgradeSafe.sol";
 import "../utils/AddressUpgradeSafe.sol";
 import "../GSN/ContextUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Contract module that allows children to implement role-based access
@@ -42,13 +42,13 @@ import "../Initializable.sol";
  * grant and revoke this role. Extra precautions should be taken to secure
  * accounts that have been granted it.
  */
-abstract contract AccessControlUpgradeSafe is __Initializable, ContextUpgradeSafe {
-    function __AccessControl_init() internal __initializer {
+abstract contract AccessControlUpgradeSafe is Initializable, ContextUpgradeSafe {
+    function __AccessControl_init() internal initializer {
         __Context_init_unchained();
         __AccessControl_init_unchained();
     }
 
-    function __AccessControl_init_unchained() internal __initializer {
+    function __AccessControl_init_unchained() internal initializer {
     }
     using EnumerableSetUpgradeSafe for EnumerableSetUpgradeSafe.AddressSet;
     using AddressUpgradeSafe for address;

contracts/access/OwnableUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "../GSN/ContextUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 /**
  * @dev Contract module which provides a basic access control mechanism, where
  * there is an account (an owner) that can be granted exclusive access to
@@ -16,7 +16,7 @@ import "../Initializable.sol";
  * `onlyOwner`, which can be applied to your functions to restrict their use to
  * the owner.
  */
-contract OwnableUpgradeSafe is __Initializable, ContextUpgradeSafe {
+contract OwnableUpgradeSafe is Initializable, ContextUpgradeSafe {
     address private _owner;
 
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
@@ -24,12 +24,12 @@ contract OwnableUpgradeSafe is __Initializable, ContextUpgradeSafe {
     /**
      * @dev Initializes the contract setting the deployer as the initial owner.
      */
-    function __Ownable_init() internal __initializer {
+    function __Ownable_init() internal initializer {
         __Context_init_unchained();
         __Ownable_init_unchained();
     }
 
-    function __Ownable_init_unchained() internal __initializer {
+    function __Ownable_init_unchained() internal initializer {
         address msgSender = _msgSender();
         _owner = msgSender;
         emit OwnershipTransferred(address(0), msgSender);

contracts/access/TimelockControllerUpgradeSafe.sol

@@ -5,7 +5,7 @@ pragma experimental ABIEncoderV2;
 
 import "./../math/SafeMathUpgradeSafe.sol";
 import "./AccessControlUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Contract module which acts as a timelocked controller. When set as the
@@ -20,7 +20,7 @@ import "../Initializable.sol";
  * to position this {TimelockController} as the owner of a smart contract, with
  * a multisig or a DAO as the sole proposer.
  */
-contract TimelockControllerUpgradeSafe is __Initializable, AccessControlUpgradeSafe {
+contract TimelockControllerUpgradeSafe is Initializable, AccessControlUpgradeSafe {
 
     bytes32 public constant TIMELOCK_ADMIN_ROLE = keccak256("TIMELOCK_ADMIN_ROLE");
     bytes32 public constant PROPOSER_ROLE = keccak256("PROPOSER_ROLE");
@@ -53,13 +53,13 @@ contract TimelockControllerUpgradeSafe is __Initializable, AccessControlUpgradeS
     /**
      * @dev Initializes the contract with a given `minDelay`.
      */
-    function __TimelockController_init(uint256 minDelay, address[] memory proposers, address[] memory executors) internal __initializer {
+    function __TimelockController_init(uint256 minDelay, address[] memory proposers, address[] memory executors) internal initializer {
         __Context_init_unchained();
         __AccessControl_init_unchained();
         __TimelockController_init_unchained(minDelay, proposers, executors);
     }
 
-    function __TimelockController_init_unchained(uint256 minDelay, address[] memory proposers, address[] memory executors) internal __initializer {
+    function __TimelockController_init_unchained(uint256 minDelay, address[] memory proposers, address[] memory executors) internal initializer {
         _setRoleAdmin(TIMELOCK_ADMIN_ROLE, TIMELOCK_ADMIN_ROLE);
         _setRoleAdmin(PROPOSER_ROLE, TIMELOCK_ADMIN_ROLE);
         _setRoleAdmin(EXECUTOR_ROLE, TIMELOCK_ADMIN_ROLE);

contracts/introspection/ERC165UpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "./IERC165UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Implementation of the {IERC165} interface.
@@ -11,7 +11,7 @@ import "../Initializable.sol";
  * Contracts may inherit from this and call {_registerInterface} to declare
  * their support of an interface.
  */
-contract ERC165UpgradeSafe is __Initializable, IERC165UpgradeSafe {
+contract ERC165UpgradeSafe is Initializable, IERC165UpgradeSafe {
     /*
      * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
      */
@@ -22,11 +22,11 @@ contract ERC165UpgradeSafe is __Initializable, IERC165UpgradeSafe {
      */
     mapping(bytes4 => bool) private _supportedInterfaces;
 
-    function __ERC165_init() internal __initializer {
+    function __ERC165_init() internal initializer {
         __ERC165_init_unchained();
     }
 
-    function __ERC165_init_unchained() internal __initializer {
+    function __ERC165_init_unchained() internal initializer {
         // Derived contracts need only register support for their own interfaces,
         // we register support for ERC165 itself here
         _registerInterface(_INTERFACE_ID_ERC165);

contracts/introspection/ERC1820ImplementerUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "./IERC1820ImplementerUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Implementation of the {IERC1820Implementer} interface.
@@ -13,12 +13,12 @@ import "../Initializable.sol";
  * {IERC1820Registry-setInterfaceImplementer} should then be called for the
  * registration to be complete.
  */
-contract ERC1820ImplementerUpgradeSafe is __Initializable, IERC1820ImplementerUpgradeSafe {
-    function __ERC1820Implementer_init() internal __initializer {
+contract ERC1820ImplementerUpgradeSafe is Initializable, IERC1820ImplementerUpgradeSafe {
+    function __ERC1820Implementer_init() internal initializer {
         __ERC1820Implementer_init_unchained();
     }
 
-    function __ERC1820Implementer_init_unchained() internal __initializer {
+    function __ERC1820Implementer_init_unchained() internal initializer {
     }
     bytes32 constant private _ERC1820_ACCEPT_MAGIC = keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC"));
 

contracts/mocks/AccessControlMockUpgradeSafe.sol

@@ -3,16 +3,16 @@
 pragma solidity ^0.6.0;
 
 import "../access/AccessControlUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract AccessControlMockUpgradeSafe is __Initializable, AccessControlUpgradeSafe {
-    function __AccessControlMock_init() internal __initializer {
+contract AccessControlMockUpgradeSafe is Initializable, AccessControlUpgradeSafe {
+    function __AccessControlMock_init() internal initializer {
         __Context_init_unchained();
         __AccessControl_init_unchained();
         __AccessControlMock_init_unchained();
     }
 
-    function __AccessControlMock_init_unchained() internal __initializer {
+    function __AccessControlMock_init_unchained() internal initializer {
         _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
     }
 

contracts/mocks/AddressImplUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../utils/AddressUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract AddressImplUpgradeSafe is __Initializable {
-    function __AddressImpl_init() internal __initializer {
+contract AddressImplUpgradeSafe is Initializable {
+    function __AddressImpl_init() internal initializer {
         __AddressImpl_init_unchained();
     }
 
-    function __AddressImpl_init_unchained() internal __initializer {
+    function __AddressImpl_init_unchained() internal initializer {
     }
     string public sharedAnswer;
 

contracts/mocks/ArraysImplUpgradeSafe.sol

@@ -3,18 +3,18 @@
 pragma solidity ^0.6.0;
 
 import "../utils/ArraysUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ArraysImplUpgradeSafe is __Initializable {
+contract ArraysImplUpgradeSafe is Initializable {
     using ArraysUpgradeSafe for uint256[];
 
     uint256[] private _array;
 
-    function __ArraysImpl_init(uint256[] memory array) internal __initializer {
+    function __ArraysImpl_init(uint256[] memory array) internal initializer {
         __ArraysImpl_init_unchained(array);
     }
 
-    function __ArraysImpl_init_unchained(uint256[] memory array) internal __initializer {
+    function __ArraysImpl_init_unchained(uint256[] memory array) internal initializer {
         _array = array;
     }
 

contracts/mocks/CallReceiverMockUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract CallReceiverMockUpgradeSafe is __Initializable {
-    function __CallReceiverMock_init() internal __initializer {
+contract CallReceiverMockUpgradeSafe is Initializable {
+    function __CallReceiverMock_init() internal initializer {
         __CallReceiverMock_init_unchained();
     }
 
-    function __CallReceiverMock_init_unchained() internal __initializer {
+    function __CallReceiverMock_init_unchained() internal initializer {
     }
     string public sharedAnswer;
 

contracts/mocks/ClashingImplementationUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 
 /**
@@ -9,12 +9,12 @@ import "../Initializable.sol";
  * @dev TransparentUpgradeableProxy's to test correct functioning of the
  * @dev Transparent Proxy feature.
  */
-contract ClashingImplementationUpgradeSafe is __Initializable {
-    function __ClashingImplementation_init() internal __initializer {
+contract ClashingImplementationUpgradeSafe is Initializable {
+    function __ClashingImplementation_init() internal initializer {
         __ClashingImplementation_init_unchained();
     }
 
-    function __ClashingImplementation_init_unchained() internal __initializer {
+    function __ClashingImplementation_init_unchained() internal initializer {
     }
 
   function admin() external pure returns (address) {

contracts/mocks/ConditionalEscrowMockUpgradeSafe.sol

@@ -3,11 +3,11 @@
 pragma solidity ^0.6.0;
 
 import "../payment/escrow/ConditionalEscrowUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // mock class using ConditionalEscrow
-contract ConditionalEscrowMockUpgradeSafe is __Initializable, ConditionalEscrowUpgradeSafe {
-    function __ConditionalEscrowMock_init() internal __initializer {
+contract ConditionalEscrowMockUpgradeSafe is Initializable, ConditionalEscrowUpgradeSafe {
+    function __ConditionalEscrowMock_init() internal initializer {
         __Context_init_unchained();
         __Ownable_init_unchained();
         __Escrow_init_unchained();
@@ -15,7 +15,7 @@ contract ConditionalEscrowMockUpgradeSafe is __Initializable, ConditionalEscrowU
         __ConditionalEscrowMock_init_unchained();
     }
 
-    function __ConditionalEscrowMock_init_unchained() internal __initializer {
+    function __ConditionalEscrowMock_init_unchained() internal initializer {
     }
     mapping(address => bool) private _allowed;
 

contracts/mocks/ContextMockUpgradeSafe.sol

@@ -3,15 +3,15 @@
 pragma solidity ^0.6.0;
 
 import "../GSN/ContextUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ContextMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
-    function __ContextMock_init() internal __initializer {
+contract ContextMockUpgradeSafe is Initializable, ContextUpgradeSafe {
+    function __ContextMock_init() internal initializer {
         __Context_init_unchained();
         __ContextMock_init_unchained();
     }
 
-    function __ContextMock_init_unchained() internal __initializer {
+    function __ContextMock_init_unchained() internal initializer {
     }
     event Sender(address sender);
 
@@ -27,12 +27,12 @@ contract ContextMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
     uint256[50] private __gap;
 }
 
-contract ContextMockCallerUpgradeSafe is __Initializable {
-    function __ContextMockCaller_init() internal __initializer {
+contract ContextMockCallerUpgradeSafe is Initializable {
+    function __ContextMockCaller_init() internal initializer {
         __ContextMockCaller_init_unchained();
     }
 
-    function __ContextMockCaller_init_unchained() internal __initializer {
+    function __ContextMockCaller_init_unchained() internal initializer {
     }
     function callSender(ContextMockUpgradeSafe context) public {
         context.msgSender();

contracts/mocks/CountersImplUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../utils/CountersUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract CountersImplUpgradeSafe is __Initializable {
-    function __CountersImpl_init() internal __initializer {
+contract CountersImplUpgradeSafe is Initializable {
+    function __CountersImpl_init() internal initializer {
         __CountersImpl_init_unchained();
     }
 
-    function __CountersImpl_init_unchained() internal __initializer {
+    function __CountersImpl_init_unchained() internal initializer {
     }
     using CountersUpgradeSafe for CountersUpgradeSafe.Counter;
 

contracts/mocks/Create2ImplUpgradeSafe.sol

@@ -4,14 +4,14 @@ pragma solidity ^0.6.0;
 
 import "../utils/Create2UpgradeSafe.sol";
 import "../introspection/ERC1820ImplementerUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract Create2ImplUpgradeSafe is __Initializable {
-    function __Create2Impl_init() internal __initializer {
+contract Create2ImplUpgradeSafe is Initializable {
+    function __Create2Impl_init() internal initializer {
         __Create2Impl_init_unchained();
     }
 
-    function __Create2Impl_init_unchained() internal __initializer {
+    function __Create2Impl_init_unchained() internal initializer {
     }
     function deploy(uint256 value, bytes32 salt, bytes memory code) public {
         Create2UpgradeSafe.deploy(value, salt, code);

contracts/mocks/DummyImplementationUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-abstract contract ImplUpgradeSafe is __Initializable {
-    function __Impl_init() internal __initializer {
+abstract contract ImplUpgradeSafe is Initializable {
+    function __Impl_init() internal initializer {
         __Impl_init_unchained();
     }
 
-    function __Impl_init_unchained() internal __initializer {
+    function __Impl_init_unchained() internal initializer {
     }
   function version() public pure virtual returns (string memory); 
     uint256[50] private __gap;
 }
 
-contract DummyImplementationUpgradeSafe is __Initializable {
-    function __DummyImplementation_init() internal __initializer {
+contract DummyImplementationUpgradeSafe is Initializable {
+    function __DummyImplementation_init() internal initializer {
         __DummyImplementation_init_unchained();
     }
 
-    function __DummyImplementation_init_unchained() internal __initializer {
+    function __DummyImplementation_init_unchained() internal initializer {
     }
   uint256 public value;
   string public text;
@@ -61,13 +61,13 @@ contract DummyImplementationUpgradeSafe is __Initializable {
     uint256[47] private __gap;
 }
 
-contract DummyImplementationV2UpgradeSafe is __Initializable, DummyImplementationUpgradeSafe {
-    function __DummyImplementationV2_init() internal __initializer {
+contract DummyImplementationV2UpgradeSafe is Initializable, DummyImplementationUpgradeSafe {
+    function __DummyImplementationV2_init() internal initializer {
         __DummyImplementation_init_unchained();
         __DummyImplementationV2_init_unchained();
     }
 
-    function __DummyImplementationV2_init_unchained() internal __initializer {
+    function __DummyImplementationV2_init_unchained() internal initializer {
     }
   function migrate(uint256 newVal) payable public {
     value = newVal;

contracts/mocks/ECDSAMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../cryptography/ECDSAUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ECDSAMockUpgradeSafe is __Initializable {
-    function __ECDSAMock_init() internal __initializer {
+contract ECDSAMockUpgradeSafe is Initializable {
+    function __ECDSAMock_init() internal initializer {
         __ECDSAMock_init_unchained();
     }
 
-    function __ECDSAMock_init_unchained() internal __initializer {
+    function __ECDSAMock_init_unchained() internal initializer {
     }
     using ECDSAUpgradeSafe for bytes32;
 

contracts/mocks/ERC1155BurnableMockUpgradeSafe.sol

@@ -3,10 +3,10 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC1155/ERC1155BurnableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC1155BurnableMockUpgradeSafe is __Initializable, ERC1155BurnableUpgradeSafe {
-    function __ERC1155BurnableMock_init(string memory uri) internal __initializer {
+contract ERC1155BurnableMockUpgradeSafe is Initializable, ERC1155BurnableUpgradeSafe {
+    function __ERC1155BurnableMock_init(string memory uri) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC1155_init_unchained(uri);
@@ -14,7 +14,7 @@ contract ERC1155BurnableMockUpgradeSafe is __Initializable, ERC1155BurnableUpgra
         __ERC1155BurnableMock_init_unchained(uri);
     }
 
-    function __ERC1155BurnableMock_init_unchained(string memory uri) internal __initializer { }
+    function __ERC1155BurnableMock_init_unchained(string memory uri) internal initializer { }
 
     function mint(address to, uint256 id, uint256 value, bytes memory data) public {
         _mint(to, id, value, data);

contracts/mocks/ERC1155MockUpgradeSafe.sol

@@ -3,21 +3,21 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC1155/ERC1155UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title ERC1155Mock
  * This mock just publicizes internal functions for testing purposes
  */
-contract ERC1155MockUpgradeSafe is __Initializable, ERC1155UpgradeSafe {
-    function __ERC1155Mock_init(string memory uri) internal __initializer {
+contract ERC1155MockUpgradeSafe is Initializable, ERC1155UpgradeSafe {
+    function __ERC1155Mock_init(string memory uri) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC1155_init_unchained(uri);
         __ERC1155Mock_init_unchained(uri);
     }
 
-    function __ERC1155Mock_init_unchained(string memory uri) internal __initializer {
+    function __ERC1155Mock_init_unchained(string memory uri) internal initializer {
         // solhint-disable-previous-line no-empty-blocks
     }
 

contracts/mocks/ERC1155PausableMockUpgradeSafe.sol

@@ -4,10 +4,10 @@ pragma solidity ^0.6.0;
 
 import "./ERC1155MockUpgradeSafe.sol";
 import "../token/ERC1155/ERC1155PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC1155PausableMockUpgradeSafe is __Initializable, ERC1155MockUpgradeSafe, ERC1155PausableUpgradeSafe {
-    function __ERC1155PausableMock_init(string memory uri) internal __initializer {
+contract ERC1155PausableMockUpgradeSafe is Initializable, ERC1155MockUpgradeSafe, ERC1155PausableUpgradeSafe {
+    function __ERC1155PausableMock_init(string memory uri) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC1155_init_unchained(uri);
@@ -17,7 +17,7 @@ contract ERC1155PausableMockUpgradeSafe is __Initializable, ERC1155MockUpgradeSa
         __ERC1155PausableMock_init_unchained(uri);
     }
 
-    function __ERC1155PausableMock_init_unchained(string memory uri) internal __initializer { }
+    function __ERC1155PausableMock_init_unchained(string memory uri) internal initializer { }
 
     function pause() external {
         _pause();

contracts/mocks/ERC1155ReceiverMockUpgradeSafe.sol

@@ -4,9 +4,9 @@ pragma solidity ^0.6.0;
 
 import "../token/ERC1155/IERC1155ReceiverUpgradeSafe.sol";
 import "./ERC165MockUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC1155ReceiverMockUpgradeSafe is __Initializable, IERC1155ReceiverUpgradeSafe, ERC165MockUpgradeSafe {
+contract ERC1155ReceiverMockUpgradeSafe is Initializable, IERC1155ReceiverUpgradeSafe, ERC165MockUpgradeSafe {
     bytes4 private _recRetval;
     bool private _recReverts;
     bytes4 private _batRetval;
@@ -20,7 +20,7 @@ contract ERC1155ReceiverMockUpgradeSafe is __Initializable, IERC1155ReceiverUpgr
         bool recReverts,
         bytes4 batRetval,
         bool batReverts
-    ) internal __initializer {
+    ) internal initializer {
         __ERC165_init_unchained();
         __ERC165Mock_init_unchained();
         __ERC1155ReceiverMock_init_unchained(recRetval, recReverts, batRetval, batReverts);
@@ -31,7 +31,7 @@ contract ERC1155ReceiverMockUpgradeSafe is __Initializable, IERC1155ReceiverUpgr
         bool recReverts,
         bytes4 batRetval,
         bool batReverts
-    ) internal __initializer {
+    ) internal initializer {
         _recRetval = recRetval;
         _recReverts = recReverts;
         _batRetval = batRetval;

contracts/mocks/ERC165/ERC165InterfacesSupportedUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "../../introspection/IERC165UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * https://eips.ethereum.org/EIPS/eip-214#specification
@@ -15,7 +15,7 @@ import "../../Initializable.sol";
  * therefore, because this contract is staticcall'd we need to not emit events (which is how solidity-coverage works)
  * solidity-coverage ignores the /mocks folder, so we duplicate its implementation here to avoid instrumenting it
  */
-contract SupportsInterfaceWithLookupMockUpgradeSafe is __Initializable, IERC165UpgradeSafe {
+contract SupportsInterfaceWithLookupMockUpgradeSafe is Initializable, IERC165UpgradeSafe {
     /*
      * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
      */
@@ -30,11 +30,11 @@ contract SupportsInterfaceWithLookupMockUpgradeSafe is __Initializable, IERC165U
      * @dev A contract implementing SupportsInterfaceWithLookup
      * implement ERC165 itself.
      */
-    function __SupportsInterfaceWithLookupMock_init() internal __initializer {
+    function __SupportsInterfaceWithLookupMock_init() internal initializer {
         __SupportsInterfaceWithLookupMock_init_unchained();
     }
 
-    function __SupportsInterfaceWithLookupMock_init_unchained() internal __initializer {
+    function __SupportsInterfaceWithLookupMock_init_unchained() internal initializer {
         _registerInterface(INTERFACE_ID_ERC165);
     }
 
@@ -55,13 +55,13 @@ contract SupportsInterfaceWithLookupMockUpgradeSafe is __Initializable, IERC165U
     uint256[49] private __gap;
 }
 
-contract ERC165InterfacesSupportedUpgradeSafe is __Initializable, SupportsInterfaceWithLookupMockUpgradeSafe {
-    function __ERC165InterfacesSupported_init(bytes4[] memory interfaceIds) internal __initializer {
+contract ERC165InterfacesSupportedUpgradeSafe is Initializable, SupportsInterfaceWithLookupMockUpgradeSafe {
+    function __ERC165InterfacesSupported_init(bytes4[] memory interfaceIds) internal initializer {
         __SupportsInterfaceWithLookupMock_init_unchained();
         __ERC165InterfacesSupported_init_unchained(interfaceIds);
     }
 
-    function __ERC165InterfacesSupported_init_unchained(bytes4[] memory interfaceIds) internal __initializer {
+    function __ERC165InterfacesSupported_init_unchained(bytes4[] memory interfaceIds) internal initializer {
         for (uint256 i = 0; i < interfaceIds.length; i++) {
             _registerInterface(interfaceIds[i]);
         }

contracts/mocks/ERC165/ERC165NotSupportedUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
-contract ERC165NotSupportedUpgradeSafe is __Initializable {    function __ERC165NotSupported_init() internal __initializer {
+contract ERC165NotSupportedUpgradeSafe is Initializable {    function __ERC165NotSupported_init() internal initializer {
         __ERC165NotSupported_init_unchained();
     }
 
-    function __ERC165NotSupported_init_unchained() internal __initializer {
+    function __ERC165NotSupported_init_unchained() internal initializer {
     }
      uint256[50] private __gap;
 }

contracts/mocks/ERC165CheckerMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../introspection/ERC165CheckerUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC165CheckerMockUpgradeSafe is __Initializable {
-    function __ERC165CheckerMock_init() internal __initializer {
+contract ERC165CheckerMockUpgradeSafe is Initializable {
+    function __ERC165CheckerMock_init() internal initializer {
         __ERC165CheckerMock_init_unchained();
     }
 
-    function __ERC165CheckerMock_init_unchained() internal __initializer {
+    function __ERC165CheckerMock_init_unchained() internal initializer {
     }
     using ERC165CheckerUpgradeSafe for address;
 

contracts/mocks/ERC165MockUpgradeSafe.sol

@@ -3,15 +3,15 @@
 pragma solidity ^0.6.0;
 
 import "../introspection/ERC165UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC165MockUpgradeSafe is __Initializable, ERC165UpgradeSafe {
-    function __ERC165Mock_init() internal __initializer {
+contract ERC165MockUpgradeSafe is Initializable, ERC165UpgradeSafe {
+    function __ERC165Mock_init() internal initializer {
         __ERC165_init_unchained();
         __ERC165Mock_init_unchained();
     }
 
-    function __ERC165Mock_init_unchained() internal __initializer {
+    function __ERC165Mock_init_unchained() internal initializer {
     }
     function registerInterface(bytes4 interfaceId) public {
         _registerInterface(interfaceId);

contracts/mocks/ERC1820ImplementerMockUpgradeSafe.sol

@@ -3,15 +3,15 @@
 pragma solidity ^0.6.0;
 
 import "../introspection/ERC1820ImplementerUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC1820ImplementerMockUpgradeSafe is __Initializable, ERC1820ImplementerUpgradeSafe {
-    function __ERC1820ImplementerMock_init() internal __initializer {
+contract ERC1820ImplementerMockUpgradeSafe is Initializable, ERC1820ImplementerUpgradeSafe {
+    function __ERC1820ImplementerMock_init() internal initializer {
         __ERC1820Implementer_init_unchained();
         __ERC1820ImplementerMock_init_unchained();
     }
 
-    function __ERC1820ImplementerMock_init_unchained() internal __initializer {
+    function __ERC1820ImplementerMock_init_unchained() internal initializer {
     }
     function registerInterfaceForAddress(bytes32 interfaceHash, address account) public {
         _registerInterfaceForAddress(interfaceHash, account);

contracts/mocks/ERC20BurnableMockUpgradeSafe.sol

@@ -3,15 +3,15 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC20/ERC20BurnableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC20BurnableMockUpgradeSafe is __Initializable, ERC20BurnableUpgradeSafe {
+contract ERC20BurnableMockUpgradeSafe is Initializable, ERC20BurnableUpgradeSafe {
     function __ERC20BurnableMock_init(
         string memory name,
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __ERC20Burnable_init_unchained();
@@ -23,7 +23,7 @@ contract ERC20BurnableMockUpgradeSafe is __Initializable, ERC20BurnableUpgradeSa
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         _mint(initialAccount, initialBalance);
     }
     uint256[50] private __gap;

contracts/mocks/ERC20CappedMockUpgradeSafe.sol

@@ -3,17 +3,17 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC20/ERC20CappedUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC20CappedMockUpgradeSafe is __Initializable, ERC20CappedUpgradeSafe {
-    function __ERC20CappedMock_init(string memory name, string memory symbol, uint256 cap) internal __initializer {
+contract ERC20CappedMockUpgradeSafe is Initializable, ERC20CappedUpgradeSafe {
+    function __ERC20CappedMock_init(string memory name, string memory symbol, uint256 cap) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __ERC20Capped_init_unchained(cap);
         __ERC20CappedMock_init_unchained(name, symbol, cap);
     }
 
-    function __ERC20CappedMock_init_unchained(string memory name, string memory symbol, uint256 cap) internal __initializer { }
+    function __ERC20CappedMock_init_unchained(string memory name, string memory symbol, uint256 cap) internal initializer { }
 
     function mint(address to, uint256 tokenId) public {
         _mint(to, tokenId);

contracts/mocks/ERC20DecimalsMockUpgradeSafe.sol

@@ -3,16 +3,16 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC20/ERC20UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC20DecimalsMockUpgradeSafe is __Initializable, ERC20UpgradeSafe {
-    function __ERC20DecimalsMock_init(string memory name, string memory symbol, uint8 decimals) internal __initializer {
+contract ERC20DecimalsMockUpgradeSafe is Initializable, ERC20UpgradeSafe {
+    function __ERC20DecimalsMock_init(string memory name, string memory symbol, uint8 decimals) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __ERC20DecimalsMock_init_unchained(name, symbol, decimals);
     }
 
-    function __ERC20DecimalsMock_init_unchained(string memory name, string memory symbol, uint8 decimals) internal __initializer {
+    function __ERC20DecimalsMock_init_unchained(string memory name, string memory symbol, uint8 decimals) internal initializer {
         _setupDecimals(decimals);
     }
     uint256[50] private __gap;

contracts/mocks/ERC20MockUpgradeSafe.sol

@@ -3,16 +3,16 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC20/ERC20UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // mock class using ERC20
-contract ERC20MockUpgradeSafe is __Initializable, ERC20UpgradeSafe {
+contract ERC20MockUpgradeSafe is Initializable, ERC20UpgradeSafe {
     function __ERC20Mock_init(
         string memory name,
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __ERC20Mock_init_unchained(name, symbol, initialAccount, initialBalance);
@@ -23,7 +23,7 @@ contract ERC20MockUpgradeSafe is __Initializable, ERC20UpgradeSafe {
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         _mint(initialAccount, initialBalance);
     }
 

contracts/mocks/ERC20PausableMockUpgradeSafe.sol

@@ -3,16 +3,16 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC20/ERC20PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // mock class using ERC20Pausable
-contract ERC20PausableMockUpgradeSafe is __Initializable, ERC20PausableUpgradeSafe {
+contract ERC20PausableMockUpgradeSafe is Initializable, ERC20PausableUpgradeSafe {
     function __ERC20PausableMock_init(
         string memory name,
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __Pausable_init_unchained();
@@ -25,7 +25,7 @@ contract ERC20PausableMockUpgradeSafe is __Initializable, ERC20PausableUpgradeSa
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         _mint(initialAccount, initialBalance);
     }
 

contracts/mocks/ERC20SnapshotMockUpgradeSafe.sol

@@ -3,16 +3,16 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC20/ERC20SnapshotUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 
-contract ERC20SnapshotMockUpgradeSafe is __Initializable, ERC20SnapshotUpgradeSafe {
+contract ERC20SnapshotMockUpgradeSafe is Initializable, ERC20SnapshotUpgradeSafe {
     function __ERC20SnapshotMock_init(
         string memory name,
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
         __ERC20Snapshot_init_unchained();
@@ -24,7 +24,7 @@ contract ERC20SnapshotMockUpgradeSafe is __Initializable, ERC20SnapshotUpgradeSa
         string memory symbol,
         address initialAccount,
         uint256 initialBalance
-    ) internal __initializer {
+    ) internal initializer {
         _mint(initialAccount, initialBalance);
     }
 

contracts/mocks/ERC721BurnableMockUpgradeSafe.sol

@@ -3,10 +3,10 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC721/ERC721BurnableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC721BurnableMockUpgradeSafe is __Initializable, ERC721BurnableUpgradeSafe {
-    function __ERC721BurnableMock_init(string memory name, string memory symbol) internal __initializer {
+contract ERC721BurnableMockUpgradeSafe is Initializable, ERC721BurnableUpgradeSafe {
+    function __ERC721BurnableMock_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC721_init_unchained(name, symbol);
@@ -14,7 +14,7 @@ contract ERC721BurnableMockUpgradeSafe is __Initializable, ERC721BurnableUpgrade
         __ERC721BurnableMock_init_unchained(name, symbol);
     }
 
-    function __ERC721BurnableMock_init_unchained(string memory name, string memory symbol) internal __initializer { }
+    function __ERC721BurnableMock_init_unchained(string memory name, string memory symbol) internal initializer { }
 
     function mint(address to, uint256 tokenId) public {
         _mint(to, tokenId);

contracts/mocks/ERC721GSNRecipientMockUpgradeSafe.sol

@@ -5,14 +5,14 @@ pragma solidity ^0.6.0;
 import "../token/ERC721/ERC721UpgradeSafe.sol";
 import "../GSN/GSNRecipientUpgradeSafe.sol";
 import "../GSN/GSNRecipientSignatureUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title ERC721GSNRecipientMock
  * A simple ERC721 mock that has GSN support enabled
  */
-contract ERC721GSNRecipientMockUpgradeSafe is __Initializable, ERC721UpgradeSafe, GSNRecipientUpgradeSafe, GSNRecipientSignatureUpgradeSafe {
-    function __ERC721GSNRecipientMock_init(string memory name, string memory symbol, address trustedSigner) internal __initializer {
+contract ERC721GSNRecipientMockUpgradeSafe is Initializable, ERC721UpgradeSafe, GSNRecipientUpgradeSafe, GSNRecipientSignatureUpgradeSafe {
+    function __ERC721GSNRecipientMock_init(string memory name, string memory symbol, address trustedSigner) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC721_init_unchained(name, symbol);
@@ -21,7 +21,7 @@ contract ERC721GSNRecipientMockUpgradeSafe is __Initializable, ERC721UpgradeSafe
         __ERC721GSNRecipientMock_init_unchained(name, symbol, trustedSigner);
     }
 
-    function __ERC721GSNRecipientMock_init_unchained(string memory name, string memory symbol, address trustedSigner) internal __initializer { }
+    function __ERC721GSNRecipientMock_init_unchained(string memory name, string memory symbol, address trustedSigner) internal initializer { }
 
     function mint(uint256 tokenId) public {
         _mint(_msgSender(), tokenId);

contracts/mocks/ERC721MockUpgradeSafe.sol

@@ -3,21 +3,21 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC721/ERC721UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title ERC721Mock
  * This mock just provides a public safeMint, mint, and burn functions for testing purposes
  */
-contract ERC721MockUpgradeSafe is __Initializable, ERC721UpgradeSafe {
-    function __ERC721Mock_init(string memory name, string memory symbol) internal __initializer {
+contract ERC721MockUpgradeSafe is Initializable, ERC721UpgradeSafe {
+    function __ERC721Mock_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC721_init_unchained(name, symbol);
         __ERC721Mock_init_unchained(name, symbol);
     }
 
-    function __ERC721Mock_init_unchained(string memory name, string memory symbol) internal __initializer { }
+    function __ERC721Mock_init_unchained(string memory name, string memory symbol) internal initializer { }
 
     function exists(uint256 tokenId) public view returns (bool) {
         return _exists(tokenId);

contracts/mocks/ERC721PausableMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC721/ERC721PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title ERC721PausableMock
  * This mock just provides a public mint, burn and exists functions for testing purposes
  */
-contract ERC721PausableMockUpgradeSafe is __Initializable, ERC721PausableUpgradeSafe {
-    function __ERC721PausableMock_init(string memory name, string memory symbol) internal __initializer {
+contract ERC721PausableMockUpgradeSafe is Initializable, ERC721PausableUpgradeSafe {
+    function __ERC721PausableMock_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC721_init_unchained(name, symbol);
@@ -19,7 +19,7 @@ contract ERC721PausableMockUpgradeSafe is __Initializable, ERC721PausableUpgrade
         __ERC721PausableMock_init_unchained(name, symbol);
     }
 
-    function __ERC721PausableMock_init_unchained(string memory name, string memory symbol) internal __initializer { }
+    function __ERC721PausableMock_init_unchained(string memory name, string memory symbol) internal initializer { }
 
     function mint(address to, uint256 tokenId) public {
         super._mint(to, tokenId);

contracts/mocks/ERC721ReceiverMockUpgradeSafe.sol

@@ -3,19 +3,19 @@
 pragma solidity ^0.6.0;
 
 import "../token/ERC721/IERC721ReceiverUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC721ReceiverMockUpgradeSafe is __Initializable, IERC721ReceiverUpgradeSafe {
+contract ERC721ReceiverMockUpgradeSafe is Initializable, IERC721ReceiverUpgradeSafe {
     bytes4 private _retval;
     bool private _reverts;
 
     event Received(address operator, address from, uint256 tokenId, bytes data, uint256 gas);
 
-    function __ERC721ReceiverMock_init(bytes4 retval, bool reverts) internal __initializer {
+    function __ERC721ReceiverMock_init(bytes4 retval, bool reverts) internal initializer {
         __ERC721ReceiverMock_init_unchained(retval, reverts);
     }
 
-    function __ERC721ReceiverMock_init_unchained(bytes4 retval, bool reverts) internal __initializer {
+    function __ERC721ReceiverMock_init_unchained(bytes4 retval, bool reverts) internal initializer {
         _retval = retval;
         _reverts = reverts;
     }

contracts/mocks/ERC777MockUpgradeSafe.sol

@@ -4,16 +4,16 @@ pragma solidity ^0.6.0;
 
 import "../GSN/ContextUpgradeSafe.sol";
 import "../token/ERC777/ERC777UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC777MockUpgradeSafe is __Initializable, ContextUpgradeSafe, ERC777UpgradeSafe {
+contract ERC777MockUpgradeSafe is Initializable, ContextUpgradeSafe, ERC777UpgradeSafe {
     function __ERC777Mock_init(
         address initialHolder,
         uint256 initialBalance,
         string memory name,
         string memory symbol,
         address[] memory defaultOperators
-    ) internal __initializer {
+    ) internal initializer {
         __Context_init_unchained();
         __ERC777_init_unchained(name, symbol, defaultOperators);
         __ERC777Mock_init_unchained(initialHolder, initialBalance, name, symbol, defaultOperators);
@@ -25,7 +25,7 @@ contract ERC777MockUpgradeSafe is __Initializable, ContextUpgradeSafe, ERC777Upg
         string memory name,
         string memory symbol,
         address[] memory defaultOperators
-    ) internal __initializer {
+    ) internal initializer {
         _mint(initialHolder, initialBalance, "", "");
     }
 

contracts/mocks/ERC777SenderRecipientMockUpgradeSafe.sol

@@ -8,16 +8,16 @@ import "../token/ERC777/IERC777SenderUpgradeSafe.sol";
 import "../token/ERC777/IERC777RecipientUpgradeSafe.sol";
 import "../introspection/IERC1820RegistryUpgradeSafe.sol";
 import "../introspection/ERC1820ImplementerUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC777SenderRecipientMockUpgradeSafe is __Initializable, ContextUpgradeSafe, IERC777SenderUpgradeSafe, IERC777RecipientUpgradeSafe, ERC1820ImplementerUpgradeSafe {
-    function __ERC777SenderRecipientMock_init() internal __initializer {
+contract ERC777SenderRecipientMockUpgradeSafe is Initializable, ContextUpgradeSafe, IERC777SenderUpgradeSafe, IERC777RecipientUpgradeSafe, ERC1820ImplementerUpgradeSafe {
+    function __ERC777SenderRecipientMock_init() internal initializer {
         __Context_init_unchained();
         __ERC1820Implementer_init_unchained();
         __ERC777SenderRecipientMock_init_unchained();
     }
 
-    function __ERC777SenderRecipientMock_init_unchained() internal __initializer {
+    function __ERC777SenderRecipientMock_init_unchained() internal initializer {
         _erc1820 = IERC1820RegistryUpgradeSafe(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
     }
     event TokensToSendCalled(

contracts/mocks/EnumerableMapMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../utils/EnumerableMapUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract EnumerableMapMockUpgradeSafe is __Initializable {
-    function __EnumerableMapMock_init() internal __initializer {
+contract EnumerableMapMockUpgradeSafe is Initializable {
+    function __EnumerableMapMock_init() internal initializer {
         __EnumerableMapMock_init_unchained();
     }
 
-    function __EnumerableMapMock_init_unchained() internal __initializer {
+    function __EnumerableMapMock_init_unchained() internal initializer {
     }
     using EnumerableMapUpgradeSafe for EnumerableMapUpgradeSafe.UintToAddressMap;
 

contracts/mocks/EnumerableSetMockUpgradeSafe.sol

@@ -3,15 +3,15 @@
 pragma solidity ^0.6.0;
 
 import "../utils/EnumerableSetUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // Bytes32Set
-contract EnumerableBytes32SetMockUpgradeSafe is __Initializable {
-    function __EnumerableBytes32SetMock_init() internal __initializer {
+contract EnumerableBytes32SetMockUpgradeSafe is Initializable {
+    function __EnumerableBytes32SetMock_init() internal initializer {
         __EnumerableBytes32SetMock_init_unchained();
     }
 
-    function __EnumerableBytes32SetMock_init_unchained() internal __initializer {
+    function __EnumerableBytes32SetMock_init_unchained() internal initializer {
     }
     using EnumerableSetUpgradeSafe for EnumerableSetUpgradeSafe.Bytes32Set;
 
@@ -44,12 +44,12 @@ contract EnumerableBytes32SetMockUpgradeSafe is __Initializable {
 }
 
 // AddressSet
-contract EnumerableAddressSetMockUpgradeSafe is __Initializable {
-    function __EnumerableAddressSetMock_init() internal __initializer {
+contract EnumerableAddressSetMockUpgradeSafe is Initializable {
+    function __EnumerableAddressSetMock_init() internal initializer {
         __EnumerableAddressSetMock_init_unchained();
     }
 
-    function __EnumerableAddressSetMock_init_unchained() internal __initializer {
+    function __EnumerableAddressSetMock_init_unchained() internal initializer {
     }
     using EnumerableSetUpgradeSafe for EnumerableSetUpgradeSafe.AddressSet;
 
@@ -82,12 +82,12 @@ contract EnumerableAddressSetMockUpgradeSafe is __Initializable {
 }
 
 // UintSet
-contract EnumerableUintSetMockUpgradeSafe is __Initializable {
-    function __EnumerableUintSetMock_init() internal __initializer {
+contract EnumerableUintSetMockUpgradeSafe is Initializable {
+    function __EnumerableUintSetMock_init() internal initializer {
         __EnumerableUintSetMock_init_unchained();
     }
 
-    function __EnumerableUintSetMock_init_unchained() internal __initializer {
+    function __EnumerableUintSetMock_init_unchained() internal initializer {
     }
     using EnumerableSetUpgradeSafe for EnumerableSetUpgradeSafe.UintSet;
 

contracts/mocks/EtherReceiverMockUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract EtherReceiverMockUpgradeSafe is __Initializable {
-    function __EtherReceiverMock_init() internal __initializer {
+contract EtherReceiverMockUpgradeSafe is Initializable {
+    function __EtherReceiverMock_init() internal initializer {
         __EtherReceiverMock_init_unchained();
     }
 
-    function __EtherReceiverMock_init_unchained() internal __initializer {
+    function __EtherReceiverMock_init_unchained() internal initializer {
     }
     bool private _acceptEther;
 

contracts/mocks/GSNRecipientERC20FeeMockUpgradeSafe.sol

@@ -4,17 +4,17 @@ pragma solidity ^0.6.0;
 
 import "../GSN/GSNRecipientUpgradeSafe.sol";
 import "../GSN/GSNRecipientERC20FeeUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract GSNRecipientERC20FeeMockUpgradeSafe is __Initializable, GSNRecipientUpgradeSafe, GSNRecipientERC20FeeUpgradeSafe {
-    function __GSNRecipientERC20FeeMock_init(string memory name, string memory symbol) internal __initializer {
+contract GSNRecipientERC20FeeMockUpgradeSafe is Initializable, GSNRecipientUpgradeSafe, GSNRecipientERC20FeeUpgradeSafe {
+    function __GSNRecipientERC20FeeMock_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __GSNRecipient_init_unchained();
         __GSNRecipientERC20Fee_init_unchained(name, symbol);
         __GSNRecipientERC20FeeMock_init_unchained(name, symbol);
     }
 
-    function __GSNRecipientERC20FeeMock_init_unchained(string memory name, string memory symbol) internal __initializer { }
+    function __GSNRecipientERC20FeeMock_init_unchained(string memory name, string memory symbol) internal initializer { }
 
     function mint(address account, uint256 amount) public {
         _mint(account, amount);

contracts/mocks/GSNRecipientMockUpgradeSafe.sol

@@ -4,18 +4,18 @@ pragma solidity ^0.6.0;
 
 import "./ContextMockUpgradeSafe.sol";
 import "../GSN/GSNRecipientUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // By inheriting from GSNRecipient, Context's internal functions are overridden automatically
-contract GSNRecipientMockUpgradeSafe is __Initializable, ContextMockUpgradeSafe, GSNRecipientUpgradeSafe {
-    function __GSNRecipientMock_init() internal __initializer {
+contract GSNRecipientMockUpgradeSafe is Initializable, ContextMockUpgradeSafe, GSNRecipientUpgradeSafe {
+    function __GSNRecipientMock_init() internal initializer {
         __Context_init_unchained();
         __ContextMock_init_unchained();
         __GSNRecipient_init_unchained();
         __GSNRecipientMock_init_unchained();
     }
 
-    function __GSNRecipientMock_init_unchained() internal __initializer {
+    function __GSNRecipientMock_init_unchained() internal initializer {
     }
     function withdrawDeposits(uint256 amount, address payable payee) public {
         _withdrawDeposits(amount, payee);

contracts/mocks/GSNRecipientSignatureMockUpgradeSafe.sol

@@ -4,17 +4,17 @@ pragma solidity ^0.6.0;
 
 import "../GSN/GSNRecipientUpgradeSafe.sol";
 import "../GSN/GSNRecipientSignatureUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract GSNRecipientSignatureMockUpgradeSafe is __Initializable, GSNRecipientUpgradeSafe, GSNRecipientSignatureUpgradeSafe {
-    function __GSNRecipientSignatureMock_init(address trustedSigner) internal __initializer {
+contract GSNRecipientSignatureMockUpgradeSafe is Initializable, GSNRecipientUpgradeSafe, GSNRecipientSignatureUpgradeSafe {
+    function __GSNRecipientSignatureMock_init(address trustedSigner) internal initializer {
         __Context_init_unchained();
         __GSNRecipient_init_unchained();
         __GSNRecipientSignature_init_unchained(trustedSigner);
         __GSNRecipientSignatureMock_init_unchained(trustedSigner);
     }
 
-    function __GSNRecipientSignatureMock_init_unchained(address trustedSigner) internal __initializer { }
+    function __GSNRecipientSignatureMock_init_unchained(address trustedSigner) internal initializer { }
 
     event MockFunctionCalled();
 

contracts/mocks/InitializableMockUpgradeSafe.sol → contracts/mocks/InitializableMock.sol

@@ -2,21 +2,13 @@
 
 pragma solidity ^0.6.0;
 
-import "../proxy/InitializableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title InitializableMock
  * @dev This contract is a mock to test initializable functionality
  */
-contract InitializableMockUpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __InitializableMock_init() internal __initializer {
-        __Initializable_init_unchained();
-        __InitializableMock_init_unchained();
-    }
-
-    function __InitializableMock_init_unchained() internal __initializer {
-    }
+contract InitializableMock is Initializable {
 
   bool public initializerRan;
   uint256 public x;
@@ -41,5 +33,4 @@ contract InitializableMockUpgradeSafe is __Initializable, InitializableUpgradeSa
     require(false, "InitializableMock forced failure");
   }
 
-    uint256[48] private __gap;
 }

contracts/mocks/MathMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../math/MathUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract MathMockUpgradeSafe is __Initializable {
-    function __MathMock_init() internal __initializer {
+contract MathMockUpgradeSafe is Initializable {
+    function __MathMock_init() internal initializer {
         __MathMock_init_unchained();
     }
 
-    function __MathMock_init_unchained() internal __initializer {
+    function __MathMock_init_unchained() internal initializer {
     }
     function max(uint256 a, uint256 b) public pure returns (uint256) {
         return MathUpgradeSafe.max(a, b);

contracts/mocks/MerkleProofWrapperUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import { MerkleProofUpgradeSafe } from "../cryptography/MerkleProofUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract MerkleProofWrapperUpgradeSafe is __Initializable {
-    function __MerkleProofWrapper_init() internal __initializer {
+contract MerkleProofWrapperUpgradeSafe is Initializable {
+    function __MerkleProofWrapper_init() internal initializer {
         __MerkleProofWrapper_init_unchained();
     }
 
-    function __MerkleProofWrapper_init_unchained() internal __initializer {
+    function __MerkleProofWrapper_init_unchained() internal initializer {
     }
     function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) public pure returns (bool) {
         return MerkleProofUpgradeSafe.verify(proof, root, leaf);

contracts/mocks/MultipleInheritanceInitializableMocksUpgradeSafe.sol → contracts/mocks/MultipleInheritanceInitializableMocks.sol

@@ -2,8 +2,7 @@
 
 pragma solidity ^0.6.0;
 
-import "../proxy/InitializableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // Sample contracts showing upgradeability with multiple inheritance.
 // Child contract inherits from Father and Mother contracts, and Father extends from Gramps.
@@ -19,107 +18,59 @@ import "../Initializable.sol";
 /**
  * Sample base intializable contract that is a human
  */
-contract SampleHumanUpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __SampleHuman_init() internal __initializer {
-        __Initializable_init_unchained();
-        __SampleHuman_init_unchained();
-    }
-
-    function __SampleHuman_init_unchained() internal __initializer {
-    }
+contract SampleHuman is Initializable {
   bool public isHuman;
 
   function initialize() public initializer {
     isHuman = true;
   }
-    uint256[49] private __gap;
 }
 
 /**
  * Sample base intializable contract that defines a field mother
  */
-contract SampleMotherUpgradeSafe is __Initializable, InitializableUpgradeSafe, SampleHumanUpgradeSafe {
-    function __SampleMother_init() internal __initializer {
-        __Initializable_init_unchained();
-        __SampleHuman_init_unchained();
-        __SampleMother_init_unchained();
-    }
-
-    function __SampleMother_init_unchained() internal __initializer {
-    }
+contract SampleMother is Initializable, SampleHuman {
   uint256 public mother;
 
   function initialize(uint256 value) public initializer virtual {
-    SampleHumanUpgradeSafe.initialize();
+    SampleHuman.initialize();
     mother = value;
   }
-    uint256[49] private __gap;
 }
 
 /**
  * Sample base intializable contract that defines a field gramps
  */
-contract SampleGrampsUpgradeSafe is __Initializable, InitializableUpgradeSafe, SampleHumanUpgradeSafe {
-    function __SampleGramps_init() internal __initializer {
-        __Initializable_init_unchained();
-        __SampleHuman_init_unchained();
-        __SampleGramps_init_unchained();
-    }
-
-    function __SampleGramps_init_unchained() internal __initializer {
-    }
+contract SampleGramps is Initializable, SampleHuman {
   string public gramps;
 
   function initialize(string memory value) public initializer virtual {
-    SampleHumanUpgradeSafe.initialize();
+    SampleHuman.initialize();
     gramps = value;
   }
-    uint256[49] private __gap;
 }
 
 /**
  * Sample base intializable contract that defines a field father and extends from gramps
  */
-contract SampleFatherUpgradeSafe is __Initializable, InitializableUpgradeSafe, SampleGrampsUpgradeSafe {
-    function __SampleFather_init() internal __initializer {
-        __Initializable_init_unchained();
-        __SampleHuman_init_unchained();
-        __SampleGramps_init_unchained();
-        __SampleFather_init_unchained();
-    }
-
-    function __SampleFather_init_unchained() internal __initializer {
-    }
+contract SampleFather is Initializable, SampleGramps {
   uint256 public father;
 
   function initialize(string memory _gramps, uint256 _father) public initializer {
-    SampleGrampsUpgradeSafe.initialize(_gramps);
+    SampleGramps.initialize(_gramps);
     father = _father;
   }
-    uint256[49] private __gap;
 }
 
 /**
  * Child extends from mother, father (gramps)
  */
-contract SampleChildUpgradeSafe is __Initializable, InitializableUpgradeSafe, SampleMotherUpgradeSafe, SampleFatherUpgradeSafe {
-    function __SampleChild_init() internal __initializer {
-        __Initializable_init_unchained();
-        __SampleHuman_init_unchained();
-        __SampleMother_init_unchained();
-        __SampleGramps_init_unchained();
-        __SampleFather_init_unchained();
-        __SampleChild_init_unchained();
-    }
-
-    function __SampleChild_init_unchained() internal __initializer {
-    }
+contract SampleChild is Initializable, SampleMother, SampleFather {
   uint256 public child;
 
   function initialize(uint256 _mother, string memory _gramps, uint256 _father, uint256 _child) public initializer {
-    SampleMotherUpgradeSafe.initialize(_mother);
-    SampleFatherUpgradeSafe.initialize(_gramps, _father);
+    SampleMother.initialize(_mother);
+    SampleFather.initialize(_gramps, _father);
     child = _child;
   }
-    uint256[49] private __gap;
 }

contracts/mocks/OwnableMockUpgradeSafe.sol

@@ -3,15 +3,15 @@
 pragma solidity ^0.6.0;
 
 import "../access/OwnableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract OwnableMockUpgradeSafe is __Initializable, OwnableUpgradeSafe {    function __OwnableMock_init() internal __initializer {
+contract OwnableMockUpgradeSafe is Initializable, OwnableUpgradeSafe {    function __OwnableMock_init() internal initializer {
         __Context_init_unchained();
         __Ownable_init_unchained();
         __OwnableMock_init_unchained();
     }
 
-    function __OwnableMock_init_unchained() internal __initializer {
+    function __OwnableMock_init_unchained() internal initializer {
     }
      uint256[50] private __gap;
 }

contracts/mocks/PausableMockUpgradeSafe.sol

@@ -3,19 +3,19 @@
 pragma solidity ^0.6.0;
 
 import "../utils/PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract PausableMockUpgradeSafe is __Initializable, PausableUpgradeSafe {
+contract PausableMockUpgradeSafe is Initializable, PausableUpgradeSafe {
     bool public drasticMeasureTaken;
     uint256 public count;
 
-    function __PausableMock_init() internal __initializer {
+    function __PausableMock_init() internal initializer {
         __Context_init_unchained();
         __Pausable_init_unchained();
         __PausableMock_init_unchained();
     }
 
-    function __PausableMock_init_unchained() internal __initializer {
+    function __PausableMock_init_unchained() internal initializer {
         drasticMeasureTaken = false;
         count = 0;
     }

contracts/mocks/PullPaymentMockUpgradeSafe.sol

@@ -3,16 +3,16 @@
 pragma solidity ^0.6.0;
 
 import "../payment/PullPaymentUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 // mock class using PullPayment
-contract PullPaymentMockUpgradeSafe is __Initializable, PullPaymentUpgradeSafe {
-    function __PullPaymentMock_init() internal __initializer {
+contract PullPaymentMockUpgradeSafe is Initializable, PullPaymentUpgradeSafe {
+    function __PullPaymentMock_init() internal initializer {
         __PullPayment_init_unchained();
         __PullPaymentMock_init_unchained();
     }
 
-    function __PullPaymentMock_init_unchained() internal __initializer { }
+    function __PullPaymentMock_init_unchained() internal initializer { }
 
     // test helper function to call asyncTransfer
     function callTransfer(address dest, uint256 amount) public {

contracts/mocks/ReentrancyAttackUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../GSN/ContextUpgradeSafe.sol";
-import "../Initializable.sol";
-contract ReentrancyAttackUpgradeSafe is __Initializable, ContextUpgradeSafe {
-    function __ReentrancyAttack_init() internal __initializer {
+import "../proxy/Initializable.sol";
+contract ReentrancyAttackUpgradeSafe is Initializable, ContextUpgradeSafe {
+    function __ReentrancyAttack_init() internal initializer {
         __Context_init_unchained();
         __ReentrancyAttack_init_unchained();
     }
 
-    function __ReentrancyAttack_init_unchained() internal __initializer {
+    function __ReentrancyAttack_init_unchained() internal initializer {
     }
     function callSender(bytes4 data) public {
         // solhint-disable-next-line avoid-low-level-calls

contracts/mocks/ReentrancyMockUpgradeSafe.sol

@@ -4,17 +4,17 @@ pragma solidity ^0.6.0;
 
 import "../utils/ReentrancyGuardUpgradeSafe.sol";
 import "./ReentrancyAttackUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ReentrancyMockUpgradeSafe is __Initializable, ReentrancyGuardUpgradeSafe {
+contract ReentrancyMockUpgradeSafe is Initializable, ReentrancyGuardUpgradeSafe {
     uint256 public counter;
 
-    function __ReentrancyMock_init() internal __initializer {
+    function __ReentrancyMock_init() internal initializer {
         __ReentrancyGuard_init_unchained();
         __ReentrancyMock_init_unchained();
     }
 
-    function __ReentrancyMock_init_unchained() internal __initializer {
+    function __ReentrancyMock_init_unchained() internal initializer {
         counter = 0;
     }
 

contracts/mocks/RegressionImplementationUpgradeSafe.sol → contracts/mocks/RegressionImplementation.sol

@@ -2,17 +2,9 @@
 
 pragma solidity ^0.6.0;
 
-import "../proxy/InitializableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract Implementation1UpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __Implementation1_init() internal __initializer {
-        __Initializable_init_unchained();
-        __Implementation1_init_unchained();
-    }
-
-    function __Implementation1_init_unchained() internal __initializer {
-    }
+contract Implementation1 is Initializable {
   uint internal _value;
 
   function initialize() public initializer {
@@ -21,17 +13,9 @@ contract Implementation1UpgradeSafe is __Initializable, InitializableUpgradeSafe
   function setValue(uint _number) public {
     _value = _number;
   }
-    uint256[49] private __gap;
 }
 
-contract Implementation2UpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __Implementation2_init() internal __initializer {
-        __Initializable_init_unchained();
-        __Implementation2_init_unchained();
-    }
-
-    function __Implementation2_init_unchained() internal __initializer {
-    }
+contract Implementation2 is Initializable {
   uint internal _value;
 
   function initialize() public initializer {
@@ -44,17 +28,9 @@ contract Implementation2UpgradeSafe is __Initializable, InitializableUpgradeSafe
   function getValue() public view returns (uint) {
     return _value;
   }
-    uint256[49] private __gap;
 }
 
-contract Implementation3UpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __Implementation3_init() internal __initializer {
-        __Initializable_init_unchained();
-        __Implementation3_init_unchained();
-    }
-
-    function __Implementation3_init_unchained() internal __initializer {
-    }
+contract Implementation3 is Initializable {
   uint internal _value;
 
   function initialize() public initializer {
@@ -67,17 +43,9 @@ contract Implementation3UpgradeSafe is __Initializable, InitializableUpgradeSafe
   function getValue(uint _number) public view returns (uint) {
     return _value + _number;
   }
-    uint256[49] private __gap;
 }
 
-contract Implementation4UpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __Implementation4_init() internal __initializer {
-        __Initializable_init_unchained();
-        __Implementation4_init_unchained();
-    }
-
-    function __Implementation4_init_unchained() internal __initializer {
-    }
+contract Implementation4 is Initializable {
   uint internal _value;
 
   function initialize() public initializer {
@@ -95,5 +63,4 @@ contract Implementation4UpgradeSafe is __Initializable, InitializableUpgradeSafe
   fallback() external {
     _value = 1;
   }
-    uint256[49] private __gap;
 }

contracts/mocks/SafeCastMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../utils/SafeCastUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract SafeCastMockUpgradeSafe is __Initializable {
-    function __SafeCastMock_init() internal __initializer {
+contract SafeCastMockUpgradeSafe is Initializable {
+    function __SafeCastMock_init() internal initializer {
         __SafeCastMock_init_unchained();
     }
 
-    function __SafeCastMock_init_unchained() internal __initializer {
+    function __SafeCastMock_init_unchained() internal initializer {
     }
     using SafeCastUpgradeSafe for uint;
     using SafeCastUpgradeSafe for int;

contracts/mocks/SafeERC20HelperUpgradeSafe.sol

@@ -5,15 +5,15 @@ pragma solidity ^0.6.0;
 import "../GSN/ContextUpgradeSafe.sol";
 import "../token/ERC20/IERC20UpgradeSafe.sol";
 import "../token/ERC20/SafeERC20UpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract ERC20ReturnFalseMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
-    function __ERC20ReturnFalseMock_init() internal __initializer {
+contract ERC20ReturnFalseMockUpgradeSafe is Initializable, ContextUpgradeSafe {
+    function __ERC20ReturnFalseMock_init() internal initializer {
         __Context_init_unchained();
         __ERC20ReturnFalseMock_init_unchained();
     }
 
-    function __ERC20ReturnFalseMock_init_unchained() internal __initializer {
+    function __ERC20ReturnFalseMock_init_unchained() internal initializer {
     }
     uint256 private _allowance;
 
@@ -43,13 +43,13 @@ contract ERC20ReturnFalseMockUpgradeSafe is __Initializable, ContextUpgradeSafe
     uint256[48] private __gap;
 }
 
-contract ERC20ReturnTrueMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
-    function __ERC20ReturnTrueMock_init() internal __initializer {
+contract ERC20ReturnTrueMockUpgradeSafe is Initializable, ContextUpgradeSafe {
+    function __ERC20ReturnTrueMock_init() internal initializer {
         __Context_init_unchained();
         __ERC20ReturnTrueMock_init_unchained();
     }
 
-    function __ERC20ReturnTrueMock_init_unchained() internal __initializer {
+    function __ERC20ReturnTrueMock_init_unchained() internal initializer {
     }
     mapping (address => uint256) private _allowances;
 
@@ -82,13 +82,13 @@ contract ERC20ReturnTrueMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
     uint256[48] private __gap;
 }
 
-contract ERC20NoReturnMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
-    function __ERC20NoReturnMock_init() internal __initializer {
+contract ERC20NoReturnMockUpgradeSafe is Initializable, ContextUpgradeSafe {
+    function __ERC20NoReturnMock_init() internal initializer {
         __Context_init_unchained();
         __ERC20NoReturnMock_init_unchained();
     }
 
-    function __ERC20NoReturnMock_init_unchained() internal __initializer {
+    function __ERC20NoReturnMock_init_unchained() internal initializer {
     }
     mapping (address => uint256) private _allowances;
 
@@ -118,17 +118,17 @@ contract ERC20NoReturnMockUpgradeSafe is __Initializable, ContextUpgradeSafe {
     uint256[48] private __gap;
 }
 
-contract SafeERC20WrapperUpgradeSafe is __Initializable, ContextUpgradeSafe {
+contract SafeERC20WrapperUpgradeSafe is Initializable, ContextUpgradeSafe {
     using SafeERC20UpgradeSafe for IERC20UpgradeSafe;
 
     IERC20UpgradeSafe private _token;
 
-    function __SafeERC20Wrapper_init(IERC20UpgradeSafe token) internal __initializer {
+    function __SafeERC20Wrapper_init(IERC20UpgradeSafe token) internal initializer {
         __Context_init_unchained();
         __SafeERC20Wrapper_init_unchained(token);
     }
 
-    function __SafeERC20Wrapper_init_unchained(IERC20UpgradeSafe token) internal __initializer {
+    function __SafeERC20Wrapper_init_unchained(IERC20UpgradeSafe token) internal initializer {
         _token = token;
     }
 

contracts/mocks/SafeMathMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../math/SafeMathUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract SafeMathMockUpgradeSafe is __Initializable {
-    function __SafeMathMock_init() internal __initializer {
+contract SafeMathMockUpgradeSafe is Initializable {
+    function __SafeMathMock_init() internal initializer {
         __SafeMathMock_init_unchained();
     }
 
-    function __SafeMathMock_init_unchained() internal __initializer {
+    function __SafeMathMock_init_unchained() internal initializer {
     }
     function mul(uint256 a, uint256 b) public pure returns (uint256) {
         return SafeMathUpgradeSafe.mul(a, b);

contracts/mocks/SignedSafeMathMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../math/SignedSafeMathUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract SignedSafeMathMockUpgradeSafe is __Initializable {
-    function __SignedSafeMathMock_init() internal __initializer {
+contract SignedSafeMathMockUpgradeSafe is Initializable {
+    function __SignedSafeMathMock_init() internal initializer {
         __SignedSafeMathMock_init_unchained();
     }
 
-    function __SignedSafeMathMock_init_unchained() internal __initializer {
+    function __SignedSafeMathMock_init_unchained() internal initializer {
     }
     function mul(int256 a, int256 b) public pure returns (int256) {
         return SignedSafeMathUpgradeSafe.mul(a, b);

contracts/mocks/SingleInheritanceInitializableMocksUpgradeSafe.sol → contracts/mocks/SingleInheritanceInitializableMocks.sol

@@ -2,42 +2,25 @@
 
 pragma solidity ^0.6.0;
 
-import "../proxy/InitializableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title MigratableMockV1
  * @dev This contract is a mock to test initializable functionality through migrations
  */
-contract MigratableMockV1UpgradeSafe is __Initializable, InitializableUpgradeSafe {
-    function __MigratableMockV1_init() internal __initializer {
-        __Initializable_init_unchained();
-        __MigratableMockV1_init_unchained();
-    }
-
-    function __MigratableMockV1_init_unchained() internal __initializer {
-    }
+contract MigratableMockV1 is Initializable {
   uint256 public x;
 
   function initialize(uint256 value) public payable initializer {
     x = value;
   }
-    uint256[49] private __gap;
 }
 
 /**
  * @title MigratableMockV2
  * @dev This contract is a mock to test migratable functionality with params
  */
-contract MigratableMockV2UpgradeSafe is __Initializable, MigratableMockV1UpgradeSafe {
-    function __MigratableMockV2_init() internal __initializer {
-        __Initializable_init_unchained();
-        __MigratableMockV1_init_unchained();
-        __MigratableMockV2_init_unchained();
-    }
-
-    function __MigratableMockV2_init_unchained() internal __initializer {
-    }
+contract MigratableMockV2 is MigratableMockV1 {
   bool internal _migratedV2;
   uint256 public y;
 
@@ -47,23 +30,13 @@ contract MigratableMockV2UpgradeSafe is __Initializable, MigratableMockV1Upgrade
     y = anotherValue;
     _migratedV2 = true;
   }
-    uint256[48] private __gap;
 }
 
 /**
  * @title MigratableMockV3
  * @dev This contract is a mock to test migratable functionality without params
  */
-contract MigratableMockV3UpgradeSafe is __Initializable, MigratableMockV2UpgradeSafe {
-    function __MigratableMockV3_init() internal __initializer {
-        __Initializable_init_unchained();
-        __MigratableMockV1_init_unchained();
-        __MigratableMockV2_init_unchained();
-        __MigratableMockV3_init_unchained();
-    }
-
-    function __MigratableMockV3_init_unchained() internal __initializer {
-    }
+contract MigratableMockV3 is MigratableMockV2 {
   bool internal _migratedV3;
 
   function migrate() public payable {
@@ -73,5 +46,4 @@ contract MigratableMockV3UpgradeSafe is __Initializable, MigratableMockV2Upgrade
     y = oldX;
     _migratedV3 = true;
   }
-    uint256[49] private __gap;
 }

contracts/mocks/StringsMockUpgradeSafe.sol

@@ -3,14 +3,14 @@
 pragma solidity ^0.6.0;
 
 import "../utils/StringsUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
-contract StringsMockUpgradeSafe is __Initializable {
-    function __StringsMock_init() internal __initializer {
+contract StringsMockUpgradeSafe is Initializable {
+    function __StringsMock_init() internal initializer {
         __StringsMock_init_unchained();
     }
 
-    function __StringsMock_init_unchained() internal __initializer {
+    function __StringsMock_init_unchained() internal initializer {
     }
     function fromUint256(uint256 value) public pure returns (string memory) {
         return StringsUpgradeSafe.toString(value);

contracts/payment/PaymentSplitterUpgradeSafe.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.6.0;
 
 import "../GSN/ContextUpgradeSafe.sol";
 import "../math/SafeMathUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @title PaymentSplitter
@@ -19,7 +19,7 @@ import "../Initializable.sol";
  * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
  * function.
  */
-contract PaymentSplitterUpgradeSafe is __Initializable, ContextUpgradeSafe {
+contract PaymentSplitterUpgradeSafe is Initializable, ContextUpgradeSafe {
     using SafeMathUpgradeSafe for uint256;
 
     event PayeeAdded(address account, uint256 shares);
@@ -40,12 +40,12 @@ contract PaymentSplitterUpgradeSafe is __Initializable, ContextUpgradeSafe {
      * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
      * duplicates in `payees`.
      */
-    function __PaymentSplitter_init(address[] memory payees, uint256[] memory shares) internal __initializer {
+    function __PaymentSplitter_init(address[] memory payees, uint256[] memory shares) internal initializer {
         __Context_init_unchained();
         __PaymentSplitter_init_unchained(payees, shares);
     }
 
-    function __PaymentSplitter_init_unchained(address[] memory payees, uint256[] memory shares) internal __initializer {
+    function __PaymentSplitter_init_unchained(address[] memory payees, uint256[] memory shares) internal initializer {
         // solhint-disable-next-line max-line-length
         require(payees.length == shares.length, "PaymentSplitter: payees and shares length mismatch");
         require(payees.length > 0, "PaymentSplitter: no payees");

contracts/payment/PullPaymentUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.2;
 
 import "./escrow/EscrowUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Simple implementation of a
@@ -23,14 +23,14 @@ import "../Initializable.sol";
  * instead of Solidity's `transfer` function. Payees can query their due
  * payments with {payments}, and retrieve them with {withdrawPayments}.
  */
-contract PullPaymentUpgradeSafe is __Initializable {
+contract PullPaymentUpgradeSafe is Initializable {
     EscrowUpgradeSafe private _escrow;
 
-    function __PullPayment_init() internal __initializer {
+    function __PullPayment_init() internal initializer {
         __PullPayment_init_unchained();
     }
 
-    function __PullPayment_init_unchained() internal __initializer {
+    function __PullPayment_init_unchained() internal initializer {
         _escrow = new EscrowUpgradeSafe();
         _escrow.initialize();
     }

contracts/payment/escrow/ConditionalEscrowUpgradeSafe.sol

@@ -3,22 +3,22 @@
 pragma solidity ^0.6.0;
 
 import "./EscrowUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @title ConditionalEscrow
  * @dev Base abstract escrow to only allow withdrawal if a condition is met.
  * @dev Intended usage: See {Escrow}. Same usage guidelines apply here.
  */
-abstract contract ConditionalEscrowUpgradeSafe is __Initializable, EscrowUpgradeSafe {
-    function __ConditionalEscrow_init() internal __initializer {
+abstract contract ConditionalEscrowUpgradeSafe is Initializable, EscrowUpgradeSafe {
+    function __ConditionalEscrow_init() internal initializer {
         __Context_init_unchained();
         __Ownable_init_unchained();
         __Escrow_init_unchained();
         __ConditionalEscrow_init_unchained();
     }
 
-    function __ConditionalEscrow_init_unchained() internal __initializer {
+    function __ConditionalEscrow_init_unchained() internal initializer {
     }
     /**
      * @dev Returns whether an address is allowed to withdraw their funds. To be

contracts/payment/escrow/EscrowUpgradeSafe.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.6.0;
 import "../../math/SafeMathUpgradeSafe.sol";
 import "../../access/OwnableUpgradeSafe.sol";
 import "../../utils/AddressUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
  /**
   * @title Escrow
@@ -20,17 +20,17 @@ import "../../Initializable.sol";
   * payment method should be its owner, and provide public methods redirecting
   * to the escrow's deposit and withdraw.
   */
-contract EscrowUpgradeSafe is __Initializable, OwnableUpgradeSafe {
-    function initialize() external __initializer {
+contract EscrowUpgradeSafe is Initializable, OwnableUpgradeSafe {
+    function initialize() external initializer {
         __Escrow_init();
     }
-    function __Escrow_init() internal __initializer {
+    function __Escrow_init() internal initializer {
         __Context_init_unchained();
         __Ownable_init_unchained();
         __Escrow_init_unchained();
     }
 
-    function __Escrow_init_unchained() internal __initializer {
+    function __Escrow_init_unchained() internal initializer {
     }
     using SafeMathUpgradeSafe for uint256;
     using AddressUpgradeSafe for address payable;

contracts/payment/escrow/RefundEscrowUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "./ConditionalEscrowUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @title RefundEscrow
@@ -15,7 +15,7 @@ import "../../Initializable.sol";
  * withdrawal by the beneficiary, or refunds to the depositors. All interactions
  * with `RefundEscrow` will be made through the owner contract.
  */
-contract RefundEscrowUpgradeSafe is __Initializable, ConditionalEscrowUpgradeSafe {
+contract RefundEscrowUpgradeSafe is Initializable, ConditionalEscrowUpgradeSafe {
     enum State { Active, Refunding, Closed }
 
     event RefundsClosed();
@@ -28,7 +28,7 @@ contract RefundEscrowUpgradeSafe is __Initializable, ConditionalEscrowUpgradeSaf
      * @dev Constructor.
      * @param beneficiary The beneficiary of the deposits.
      */
-    function __RefundEscrow_init(address payable beneficiary) internal __initializer {
+    function __RefundEscrow_init(address payable beneficiary) internal initializer {
         __Context_init_unchained();
         __Ownable_init_unchained();
         __Escrow_init_unchained();
@@ -36,7 +36,7 @@ contract RefundEscrowUpgradeSafe is __Initializable, ConditionalEscrowUpgradeSaf
         __RefundEscrow_init_unchained(beneficiary);
     }
 
-    function __RefundEscrow_init_unchained(address payable beneficiary) internal __initializer {
+    function __RefundEscrow_init_unchained(address payable beneficiary) internal initializer {
         require(beneficiary != address(0), "RefundEscrow: beneficiary is the zero address");
         _beneficiary = beneficiary;
         _state = State.Active;

contracts/presets/ERC1155PresetMinterPauserUpgradeSafe.sol

@@ -7,7 +7,7 @@ import "../GSN/ContextUpgradeSafe.sol";
 import "../token/ERC1155/ERC1155UpgradeSafe.sol";
 import "../token/ERC1155/ERC1155BurnableUpgradeSafe.sol";
 import "../token/ERC1155/ERC1155PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev {ERC1155} token, including:
@@ -23,7 +23,7 @@ import "../Initializable.sol";
  * roles, as well as the default admin role, which will let it grant both minter
  * and pauser roles to other accounts.
  */
-contract ERC1155PresetMinterPauserUpgradeSafe is __Initializable, ContextUpgradeSafe, AccessControlUpgradeSafe, ERC1155BurnableUpgradeSafe, ERC1155PausableUpgradeSafe {
+contract ERC1155PresetMinterPauserUpgradeSafe is Initializable, ContextUpgradeSafe, AccessControlUpgradeSafe, ERC1155BurnableUpgradeSafe, ERC1155PausableUpgradeSafe {
     bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
     bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
 
@@ -31,7 +31,7 @@ contract ERC1155PresetMinterPauserUpgradeSafe is __Initializable, ContextUpgrade
      * @dev Grants `DEFAULT_ADMIN_ROLE`, `MINTER_ROLE`, and `PAUSER_ROLE` to the account that
      * deploys the contract.
      */
-    function __ERC1155PresetMinterPauser_init(string memory uri) internal __initializer {
+    function __ERC1155PresetMinterPauser_init(string memory uri) internal initializer {
         __Context_init_unchained();
         __AccessControl_init_unchained();
         __ERC165_init_unchained();
@@ -42,7 +42,7 @@ contract ERC1155PresetMinterPauserUpgradeSafe is __Initializable, ContextUpgrade
         __ERC1155PresetMinterPauser_init_unchained(uri);
     }
 
-    function __ERC1155PresetMinterPauser_init_unchained(string memory uri) internal __initializer {
+    function __ERC1155PresetMinterPauser_init_unchained(string memory uri) internal initializer {
         _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
 
         _setupRole(MINTER_ROLE, _msgSender());

contracts/presets/ERC20PresetMinterPauserUpgradeSafe.sol

@@ -7,7 +7,7 @@ import "../GSN/ContextUpgradeSafe.sol";
 import "../token/ERC20/ERC20UpgradeSafe.sol";
 import "../token/ERC20/ERC20BurnableUpgradeSafe.sol";
 import "../token/ERC20/ERC20PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev {ERC20} token, including:
@@ -23,7 +23,7 @@ import "../Initializable.sol";
  * roles, as well as the default admin role, which will let it grant both minter
  * and pauser roles to other accounts.
  */
-contract ERC20PresetMinterPauserUpgradeSafe is __Initializable, ContextUpgradeSafe, AccessControlUpgradeSafe, ERC20BurnableUpgradeSafe, ERC20PausableUpgradeSafe {
+contract ERC20PresetMinterPauserUpgradeSafe is Initializable, ContextUpgradeSafe, AccessControlUpgradeSafe, ERC20BurnableUpgradeSafe, ERC20PausableUpgradeSafe {
     bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
     bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
 
@@ -33,7 +33,7 @@ contract ERC20PresetMinterPauserUpgradeSafe is __Initializable, ContextUpgradeSa
      *
      * See {ERC20-constructor}.
      */
-    function __ERC20PresetMinterPauser_init(string memory name, string memory symbol) internal __initializer {
+    function __ERC20PresetMinterPauser_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __AccessControl_init_unchained();
         __ERC20_init_unchained(name, symbol);
@@ -43,7 +43,7 @@ contract ERC20PresetMinterPauserUpgradeSafe is __Initializable, ContextUpgradeSa
         __ERC20PresetMinterPauser_init_unchained(name, symbol);
     }
 
-    function __ERC20PresetMinterPauser_init_unchained(string memory name, string memory symbol) internal __initializer {
+    function __ERC20PresetMinterPauser_init_unchained(string memory name, string memory symbol) internal initializer {
         _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
 
         _setupRole(MINTER_ROLE, _msgSender());

contracts/presets/ERC721PresetMinterPauserAutoIdUpgradeSafe.sol

@@ -8,7 +8,7 @@ import "../utils/CountersUpgradeSafe.sol";
 import "../token/ERC721/ERC721UpgradeSafe.sol";
 import "../token/ERC721/ERC721BurnableUpgradeSafe.sol";
 import "../token/ERC721/ERC721PausableUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev {ERC721} token, including:
@@ -25,7 +25,7 @@ import "../Initializable.sol";
  * roles, as well as the default admin role, which will let it grant both minter
  * and pauser roles to other accounts.
  */
-contract ERC721PresetMinterPauserAutoIdUpgradeSafe is __Initializable, ContextUpgradeSafe, AccessControlUpgradeSafe, ERC721BurnableUpgradeSafe, ERC721PausableUpgradeSafe {
+contract ERC721PresetMinterPauserAutoIdUpgradeSafe is Initializable, ContextUpgradeSafe, AccessControlUpgradeSafe, ERC721BurnableUpgradeSafe, ERC721PausableUpgradeSafe {
     using CountersUpgradeSafe for CountersUpgradeSafe.Counter;
 
     bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
@@ -40,7 +40,7 @@ contract ERC721PresetMinterPauserAutoIdUpgradeSafe is __Initializable, ContextUp
      * Token URIs will be autogenerated based on `baseURI` and their token IDs.
      * See {ERC721-tokenURI}.
      */
-    function __ERC721PresetMinterPauserAutoId_init(string memory name, string memory symbol, string memory baseURI) internal __initializer {
+    function __ERC721PresetMinterPauserAutoId_init(string memory name, string memory symbol, string memory baseURI) internal initializer {
         __Context_init_unchained();
         __AccessControl_init_unchained();
         __ERC165_init_unchained();
@@ -51,7 +51,7 @@ contract ERC721PresetMinterPauserAutoIdUpgradeSafe is __Initializable, ContextUp
         __ERC721PresetMinterPauserAutoId_init_unchained(name, symbol, baseURI);
     }
 
-    function __ERC721PresetMinterPauserAutoId_init_unchained(string memory name, string memory symbol, string memory baseURI) internal __initializer {
+    function __ERC721PresetMinterPauserAutoId_init_unchained(string memory name, string memory symbol, string memory baseURI) internal initializer {
         _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
 
         _setupRole(MINTER_ROLE, _msgSender());

contracts/proxy/InitializableUpgradeSafe.sol → contracts/proxy/Initializable.sol

@@ -2,7 +2,6 @@
 
 // solhint-disable-next-line compiler-version
 pragma solidity >=0.4.24 <0.7.0;
-import "../Initializable.sol";
 
 
 /**
@@ -17,13 +16,7 @@ import "../Initializable.sol";
  * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
  * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
  */
-abstract contract InitializableUpgradeSafe is __Initializable {
-    function __Initializable_init() internal __initializer {
-        __Initializable_init_unchained();
-    }
-
-    function __Initializable_init_unchained() internal __initializer {
-    }
+abstract contract Initializable {
 
     /**
      * @dev Indicates that the contract has been initialized.
@@ -67,5 +60,4 @@ abstract contract InitializableUpgradeSafe is __Initializable {
         assembly { cs := extcodesize(self) }
         return cs == 0;
     }
-    uint256[49] private __gap;
 }

contracts/proxy/ProxyAdminUpgradeSafe.sol

-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.6.0;
-
-import "../access/OwnableUpgradeSafe.sol";
-import "./TransparentUpgradeableProxyUpgradeSafe.sol";
-import "../Initializable.sol";
-
-/**
- * @dev This is an auxiliary contract meant to be assigned as the admin of a {TransparentUpgradeableProxy}. For an
- * explanation of why you would want to use this see the documentation for {TransparentUpgradeableProxy}.
- */
-contract ProxyAdminUpgradeSafe is __Initializable, OwnableUpgradeSafe {
-    function __ProxyAdmin_init() internal __initializer {
-        __Context_init_unchained();
-        __Ownable_init_unchained();
-        __ProxyAdmin_init_unchained();
-    }
-
-    function __ProxyAdmin_init_unchained() internal __initializer {
-    }
-
-    /**
-     * @dev Returns the current implementation of `proxy`.
-     * 
-     * Requirements:
-     * 
-     * - This contract must be the admin of `proxy`.
-     */
-    function getProxyImplementation(TransparentUpgradeableProxyUpgradeSafe proxy) public view returns (address) {
-        // We need to manually run the static call since the getter cannot be flagged as view
-        // bytes4(keccak256("implementation()")) == 0x5c60da1b
-        (bool success, bytes memory returndata) = address(proxy).staticcall(hex"5c60da1b");
-        require(success);
-        return abi.decode(returndata, (address));
-    }
-
-    /**
-     * @dev Returns the current admin of `proxy`.
-     * 
-     * Requirements:
-     * 
-     * - This contract must be the admin of `proxy`.
-     */
-    function getProxyAdmin(TransparentUpgradeableProxyUpgradeSafe proxy) public view returns (address) {
-        // We need to manually run the static call since the getter cannot be flagged as view
-        // bytes4(keccak256("admin()")) == 0xf851a440
-        (bool success, bytes memory returndata) = address(proxy).staticcall(hex"f851a440");
-        require(success);
-        return abi.decode(returndata, (address));
-    }
-
-    /**
-     * @dev Changes the admin of `proxy` to `newAdmin`.
-     * 
-     * Requirements:
-     * 
-     * - This contract must be the current admin of `proxy`.
-     */
-    function changeProxyAdmin(TransparentUpgradeableProxyUpgradeSafe proxy, address newAdmin) public onlyOwner {
-        proxy.changeAdmin(newAdmin);
-    }
-
-    /**
-     * @dev Upgrades `proxy` to `implementation`. See {TransparentUpgradeableProxy-upgradeTo}.
-     * 
-     * Requirements:
-     * 
-     * - This contract must be the admin of `proxy`.
-     */
-    function upgrade(TransparentUpgradeableProxyUpgradeSafe proxy, address implementation) public onlyOwner {
-        proxy.upgradeTo(implementation);
-    }
-
-    /**
-     * @dev Upgrades `proxy` to `implementation` and calls a function on the new implementation. See
-     * {TransparentUpgradeableProxy-upgradeToAndCall}.
-     * 
-     * Requirements:
-     * 
-     * - This contract must be the admin of `proxy`.
-     */
-    function upgradeAndCall(TransparentUpgradeableProxyUpgradeSafe proxy, address implementation, bytes memory data) public payable onlyOwner {
-        proxy.upgradeToAndCall{value: msg.value}(implementation, data);
-    }
-    uint256[50] private __gap;
-}

contracts/proxy/ProxyUpgradeSafe.sol

-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.6.0;
-import "../Initializable.sol";
-
-/**
- * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
- * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
- * be specified by overriding the virtual {_implementation} function.
- * 
- * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
- * different contract through the {_delegate} function.
- * 
- * The success and return data of the delegated call will be returned back to the caller of the proxy.
- */
-abstract contract ProxyUpgradeSafe is __Initializable {
-    function __Proxy_init() internal __initializer {
-        __Proxy_init_unchained();
-    }
-
-    function __Proxy_init_unchained() internal __initializer {
-    }
-    /**
-     * @dev Delegates the current call to `implementation`.
-     * 
-     * This function does not return to its internall call site, it will return directly to the external caller.
-     */
-    function _delegate(address implementation) internal {
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            // Copy msg.data. We take full control of memory in this inline assembly
-            // block because it will not return to Solidity code. We overwrite the
-            // Solidity scratch pad at memory position 0.
-            calldatacopy(0, 0, calldatasize())
-
-            // Call the implementation.
-            // out and outsize are 0 because we don't know the size yet.
-            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()) }
-        }
-    }
-
-    /**
-     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
-     * and {_fallback} should delegate.
-     */
-    function _implementation() internal virtual view returns (address);
-
-    /**
-     * @dev Delegates the current call to the address returned by `_implementation()`.
-     * 
-     * This function does not return to its internall call site, it will return directly to the external caller.
-     */
-    function _fallback() internal {
-        _beforeFallback();
-        _delegate(_implementation());
-    }
-
-    /**
-     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
-     * function in the contract matches the call data.
-     */
-    fallback () payable external {
-        _fallback();
-    }
-
-    /**
-     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
-     * is empty.
-     */
-    receive () payable external {
-        _fallback();
-    }
-
-    /**
-     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
-     * call, or as part of the Solidity `fallback` or `receive` functions.
-     * 
-     * If overriden should call `super._beforeFallback()`.
-     */
-    function _beforeFallback() internal virtual {
-    }
-    uint256[50] private __gap;
-}

contracts/proxy/TransparentUpgradeableProxyUpgradeSafe.sol

-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.6.0;
-
-import "./UpgradeableProxyUpgradeSafe.sol";
-import "../Initializable.sol";
-
-/**
- * @dev This contract implements a proxy that is upgradeable by an admin.
- * 
- * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
- * clashing], which can potentially be used in an attack, this contract uses the
- * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
- * things that go hand in hand:
- * 
- * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
- * that call matches one of the admin functions exposed by the proxy itself.
- * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
- * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
- * "admin cannot fallback to proxy target".
- * 
- * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
- * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
- * to sudden errors when trying to call a function from the proxy implementation.
- * 
- * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
- * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
- */
-contract TransparentUpgradeableProxyUpgradeSafe is __Initializable, UpgradeableProxyUpgradeSafe {
-    /**
-     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
-     * optionally initialized with `_data` as explained in {UpgradeableProxy-constructor}.
-     */
-    function __TransparentUpgradeableProxy_init(address _logic, address _admin, bytes memory _data) internal __initializer {
-        __Proxy_init_unchained();
-        __UpgradeableProxy_init_unchained(_logic, _data);
-        __TransparentUpgradeableProxy_init_unchained(_logic, _admin, _data);
-    }
-
-    function __TransparentUpgradeableProxy_init_unchained(address _logic, address _admin, bytes memory _data) internal __initializer {
-        assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
-        _setAdmin(_admin);
-    }
-
-    /**
-     * @dev Emitted when the admin account has changed.
-     */
-    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 private constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
-
-    /**
-     * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
-     */
-    modifier ifAdmin() {
-        if (msg.sender == _admin()) {
-            _;
-        } else {
-            _fallback();
-        }
-    }
-
-    /**
-     * @dev Returns the current admin.
-     * 
-     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
-     * 
-     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
-     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
-     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
-     */
-    function admin() external ifAdmin returns (address) {
-        return _admin();
-    }
-
-    /**
-     * @dev Returns the current implementation.
-     * 
-     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
-     * 
-     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
-     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
-     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
-     */
-    function implementation() external ifAdmin returns (address) {
-        return _implementation();
-    }
-
-    /**
-     * @dev Changes the admin of the proxy.
-     * 
-     * Emits an {AdminChanged} event.
-     * 
-     * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
-     */
-    function changeAdmin(address newAdmin) external ifAdmin {
-        require(newAdmin != address(0), "TransparentUpgradeableProxy: new admin is the zero address");
-        emit AdminChanged(_admin(), newAdmin);
-        _setAdmin(newAdmin);
-    }
-
-    /**
-     * @dev Upgrade the implementation of the proxy.
-     * 
-     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
-     */
-    function upgradeTo(address newImplementation) external ifAdmin {
-        _upgradeTo(newImplementation);
-    }
-
-    /**
-     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
-     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
-     * proxied contract.
-     * 
-     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
-     */
-    function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
-        _upgradeTo(newImplementation);
-        // solhint-disable-next-line avoid-low-level-calls
-        (bool success,) = newImplementation.delegatecall(data);
-        require(success);
-    }
-
-    /**
-     * @dev Returns the current admin.
-     */
-    function _admin() internal view returns (address adm) {
-        bytes32 slot = _ADMIN_SLOT;
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            adm := sload(slot)
-        }
-    }
-
-    /**
-     * @dev Stores a new address in the EIP1967 admin slot.
-     */
-    function _setAdmin(address newAdmin) private {
-        bytes32 slot = _ADMIN_SLOT;
-
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            sstore(slot, newAdmin)
-        }
-    }
-
-    /**
-     * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
-     */
-    function _beforeFallback() internal override virtual {
-        require(msg.sender != _admin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
-        super._beforeFallback();
-    }
-    uint256[50] private __gap;
-}

contracts/proxy/UpgradeableProxyUpgradeSafe.sol

-// SPDX-License-Identifier: MIT
-
-pragma solidity ^0.6.0;
-
-import "./ProxyUpgradeSafe.sol";
-import "../utils/AddressUpgradeSafe.sol";
-import "../Initializable.sol";
-
-/**
- * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
- * implementation address that can be changed. This address is stored in storage in the location specified by
- * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
- * implementation behind the proxy.
- * 
- * Upgradeability is only provided internally through {_upgradeTo}. For an externally upgradeable proxy see
- * {TransparentUpgradeableProxy}.
- */
-contract UpgradeableProxyUpgradeSafe is __Initializable, ProxyUpgradeSafe {
-    /**
-     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
-     * 
-     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
-     * function call, and allows initializating the storage of the proxy like a Solidity constructor.
-     */
-    function __UpgradeableProxy_init(address _logic, bytes memory _data) internal __initializer {
-        __Proxy_init_unchained();
-        __UpgradeableProxy_init_unchained(_logic, _data);
-    }
-
-    function __UpgradeableProxy_init_unchained(address _logic, bytes memory _data) internal __initializer {
-        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
-        _setImplementation(_logic);
-        if(_data.length > 0) {
-            // solhint-disable-next-line avoid-low-level-calls
-            (bool success,) = _logic.delegatecall(_data);
-            require(success);
-        }
-    }
-
-    /**
-     * @dev Emitted when the implementation is upgraded.
-     */
-    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 private constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
-
-    /**
-     * @dev Returns the current implementation address.
-     */
-    function _implementation() internal override view returns (address impl) {
-        bytes32 slot = _IMPLEMENTATION_SLOT;
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            impl := sload(slot)
-        }
-    }
-
-    /**
-     * @dev Upgrades the proxy to a new implementation.
-     * 
-     * Emits an {Upgraded} event.
-     */
-    function _upgradeTo(address newImplementation) internal {
-        _setImplementation(newImplementation);
-        emit Upgraded(newImplementation);
-    }
-
-    /**
-     * @dev Stores a new address in the EIP1967 implementation slot.
-     */
-    function _setImplementation(address newImplementation) private {
-        require(AddressUpgradeSafe.isContract(newImplementation), "UpgradeableProxy: new implementation is not a contract");
-
-        bytes32 slot = _IMPLEMENTATION_SLOT;
-
-        // solhint-disable-next-line no-inline-assembly
-        assembly {
-            sstore(slot, newImplementation)
-        }
-    }
-    uint256[50] private __gap;
-}

contracts/token/ERC1155/ERC1155BurnableUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "./ERC1155UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev Extension of {ERC1155} that allows token holders to destroy both their
@@ -11,14 +11,14 @@ import "../../Initializable.sol";
  *
  * _Available since v3.1._
  */
-abstract contract ERC1155BurnableUpgradeSafe is __Initializable, ERC1155UpgradeSafe {
-    function __ERC1155Burnable_init() internal __initializer {
+abstract contract ERC1155BurnableUpgradeSafe is Initializable, ERC1155UpgradeSafe {
+    function __ERC1155Burnable_init() internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC1155Burnable_init_unchained();
     }
 
-    function __ERC1155Burnable_init_unchained() internal __initializer {
+    function __ERC1155Burnable_init_unchained() internal initializer {
     }
     function burn(address account, uint256 id, uint256 value) public virtual {
         require(

contracts/token/ERC1155/ERC1155HolderUpgradeSafe.sol

@@ -3,19 +3,19 @@
 pragma solidity ^0.6.0;
 
 import "./ERC1155ReceiverUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev _Available since v3.1._
  */
-contract ERC1155HolderUpgradeSafe is __Initializable, ERC1155ReceiverUpgradeSafe {
-    function __ERC1155Holder_init() internal __initializer {
+contract ERC1155HolderUpgradeSafe is Initializable, ERC1155ReceiverUpgradeSafe {
+    function __ERC1155Holder_init() internal initializer {
         __ERC165_init_unchained();
         __ERC1155Receiver_init_unchained();
         __ERC1155Holder_init_unchained();
     }
 
-    function __ERC1155Holder_init_unchained() internal __initializer {
+    function __ERC1155Holder_init_unchained() internal initializer {
     }
     function onERC1155Received(address, address, uint256, uint256, bytes memory) public virtual override returns (bytes4) {
         return this.onERC1155Received.selector;

contracts/token/ERC1155/ERC1155PausableUpgradeSafe.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.6.0;
 
 import "./ERC1155UpgradeSafe.sol";
 import "../../utils/PausableUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev ERC1155 token with pausable token transfers, minting and burning.
@@ -15,15 +15,15 @@ import "../../Initializable.sol";
  *
  * _Available since v3.1._
  */
-abstract contract ERC1155PausableUpgradeSafe is __Initializable, ERC1155UpgradeSafe, PausableUpgradeSafe {
-    function __ERC1155Pausable_init() internal __initializer {
+abstract contract ERC1155PausableUpgradeSafe is Initializable, ERC1155UpgradeSafe, PausableUpgradeSafe {
+    function __ERC1155Pausable_init() internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __Pausable_init_unchained();
         __ERC1155Pausable_init_unchained();
     }
 
-    function __ERC1155Pausable_init_unchained() internal __initializer {
+    function __ERC1155Pausable_init_unchained() internal initializer {
     }
     /**
      * @dev See {ERC1155-_beforeTokenTransfer}.

contracts/token/ERC1155/ERC1155ReceiverUpgradeSafe.sol

@@ -4,18 +4,18 @@ pragma solidity ^0.6.0;
 
 import "./IERC1155ReceiverUpgradeSafe.sol";
 import "../../introspection/ERC165UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev _Available since v3.1._
  */
-abstract contract ERC1155ReceiverUpgradeSafe is __Initializable, ERC165UpgradeSafe, IERC1155ReceiverUpgradeSafe {
-    function __ERC1155Receiver_init() internal __initializer {
+abstract contract ERC1155ReceiverUpgradeSafe is Initializable, ERC165UpgradeSafe, IERC1155ReceiverUpgradeSafe {
+    function __ERC1155Receiver_init() internal initializer {
         __ERC165_init_unchained();
         __ERC1155Receiver_init_unchained();
     }
 
-    function __ERC1155Receiver_init_unchained() internal __initializer {
+    function __ERC1155Receiver_init_unchained() internal initializer {
         _registerInterface(
             ERC1155ReceiverUpgradeSafe(0).onERC1155Received.selector ^
             ERC1155ReceiverUpgradeSafe(0).onERC1155BatchReceived.selector

contracts/token/ERC1155/ERC1155UpgradeSafe.sol

@@ -9,7 +9,7 @@ import "../../GSN/ContextUpgradeSafe.sol";
 import "../../introspection/ERC165UpgradeSafe.sol";
 import "../../math/SafeMathUpgradeSafe.sol";
 import "../../utils/AddressUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  *
@@ -19,7 +19,7 @@ import "../../Initializable.sol";
  *
  * _Available since v3.1._
  */
-contract ERC1155UpgradeSafe is __Initializable, ContextUpgradeSafe, ERC165UpgradeSafe, IERC1155UpgradeSafe, IERC1155MetadataURIUpgradeSafe {
+contract ERC1155UpgradeSafe is Initializable, ContextUpgradeSafe, ERC165UpgradeSafe, IERC1155UpgradeSafe, IERC1155MetadataURIUpgradeSafe {
     using SafeMathUpgradeSafe for uint256;
     using AddressUpgradeSafe for address;
 
@@ -53,13 +53,13 @@ contract ERC1155UpgradeSafe is __Initializable, ContextUpgradeSafe, ERC165Upgrad
     /**
      * @dev See {_setURI}.
      */
-    function __ERC1155_init(string memory uri) internal __initializer {
+    function __ERC1155_init(string memory uri) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC1155_init_unchained(uri);
     }
 
-    function __ERC1155_init_unchained(string memory uri) internal __initializer {
+    function __ERC1155_init_unchained(string memory uri) internal initializer {
         _setURI(uri);
 
         // register the supported interfaces to conform to ERC1155 via ERC165

contracts/token/ERC20/ERC20BurnableUpgradeSafe.sol

@@ -4,20 +4,20 @@ pragma solidity ^0.6.0;
 
 import "../../GSN/ContextUpgradeSafe.sol";
 import "./ERC20UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev Extension of {ERC20} that allows token holders to destroy both their own
  * tokens and those that they have an allowance for, in a way that can be
  * recognized off-chain (via event analysis).
  */
-abstract contract ERC20BurnableUpgradeSafe is __Initializable, ContextUpgradeSafe, ERC20UpgradeSafe {
-    function __ERC20Burnable_init() internal __initializer {
+abstract contract ERC20BurnableUpgradeSafe is Initializable, ContextUpgradeSafe, ERC20UpgradeSafe {
+    function __ERC20Burnable_init() internal initializer {
         __Context_init_unchained();
         __ERC20Burnable_init_unchained();
     }
 
-    function __ERC20Burnable_init_unchained() internal __initializer {
+    function __ERC20Burnable_init_unchained() internal initializer {
     }
     /**
      * @dev Destroys `amount` tokens from the caller.

contracts/token/ERC20/ERC20CappedUpgradeSafe.sol

@@ -3,24 +3,24 @@
 pragma solidity ^0.6.0;
 
 import "./ERC20UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev Extension of {ERC20} that adds a cap to the supply of tokens.
  */
-abstract contract ERC20CappedUpgradeSafe is __Initializable, ERC20UpgradeSafe {
+abstract contract ERC20CappedUpgradeSafe is Initializable, ERC20UpgradeSafe {
     uint256 private _cap;
 
     /**
      * @dev Sets the value of the `cap`. This value is immutable, it can only be
      * set once during construction.
      */
-    function __ERC20Capped_init(uint256 cap) internal __initializer {
+    function __ERC20Capped_init(uint256 cap) internal initializer {
         __Context_init_unchained();
         __ERC20Capped_init_unchained(cap);
     }
 
-    function __ERC20Capped_init_unchained(uint256 cap) internal __initializer {
+    function __ERC20Capped_init_unchained(uint256 cap) internal initializer {
         require(cap > 0, "ERC20Capped: cap is 0");
         _cap = cap;
     }

contracts/token/ERC20/ERC20PausableUpgradeSafe.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.6.0;
 
 import "./ERC20UpgradeSafe.sol";
 import "../../utils/PausableUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev ERC20 token with pausable token transfers, minting and burning.
@@ -13,14 +13,14 @@ import "../../Initializable.sol";
  * period, or having an emergency switch for freezing all token transfers in the
  * event of a large bug.
  */
-abstract contract ERC20PausableUpgradeSafe is __Initializable, ERC20UpgradeSafe, PausableUpgradeSafe {
-    function __ERC20Pausable_init() internal __initializer {
+abstract contract ERC20PausableUpgradeSafe is Initializable, ERC20UpgradeSafe, PausableUpgradeSafe {
+    function __ERC20Pausable_init() internal initializer {
         __Context_init_unchained();
         __Pausable_init_unchained();
         __ERC20Pausable_init_unchained();
     }
 
-    function __ERC20Pausable_init_unchained() internal __initializer {
+    function __ERC20Pausable_init_unchained() internal initializer {
     }
     /**
      * @dev See {ERC20-_beforeTokenTransfer}.

contracts/token/ERC20/ERC20SnapshotUpgradeSafe.sol

@@ -6,7 +6,7 @@ import "../../math/SafeMathUpgradeSafe.sol";
 import "../../utils/ArraysUpgradeSafe.sol";
 import "../../utils/CountersUpgradeSafe.sol";
 import "./ERC20UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
@@ -32,13 +32,13 @@ import "../../Initializable.sol";
  * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
  * transfers will have normal cost until the next snapshot, and so on.
  */
-abstract contract ERC20SnapshotUpgradeSafe is __Initializable, ERC20UpgradeSafe {
-    function __ERC20Snapshot_init() internal __initializer {
+abstract contract ERC20SnapshotUpgradeSafe is Initializable, ERC20UpgradeSafe {
+    function __ERC20Snapshot_init() internal initializer {
         __Context_init_unchained();
         __ERC20Snapshot_init_unchained();
     }
 
-    function __ERC20Snapshot_init_unchained() internal __initializer {
+    function __ERC20Snapshot_init_unchained() internal initializer {
     }
     // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
     // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

contracts/token/ERC20/ERC20UpgradeSafe.sol

@@ -5,7 +5,7 @@ pragma solidity ^0.6.0;
 import "../../GSN/ContextUpgradeSafe.sol";
 import "./IERC20UpgradeSafe.sol";
 import "../../math/SafeMathUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev Implementation of the {IERC20} interface.
@@ -31,7 +31,7 @@ import "../../Initializable.sol";
  * functions have been added to mitigate the well-known issues around setting
  * allowances. See {IERC20-approve}.
  */
-contract ERC20UpgradeSafe is __Initializable, ContextUpgradeSafe, IERC20UpgradeSafe {
+contract ERC20UpgradeSafe is Initializable, ContextUpgradeSafe, IERC20UpgradeSafe {
     using SafeMathUpgradeSafe for uint256;
 
     mapping (address => uint256) private _balances;
@@ -53,12 +53,12 @@ contract ERC20UpgradeSafe is __Initializable, ContextUpgradeSafe, IERC20UpgradeS
      * All three of these values are immutable: they can only be set once during
      * construction.
      */
-    function __ERC20_init(string memory name, string memory symbol) internal __initializer {
+    function __ERC20_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __ERC20_init_unchained(name, symbol);
     }
 
-    function __ERC20_init_unchained(string memory name, string memory symbol) internal __initializer {
+    function __ERC20_init_unchained(string memory name, string memory symbol) internal initializer {
         _name = name;
         _symbol = symbol;
         _decimals = 18;

contracts/token/ERC20/TokenTimelockUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "./SafeERC20UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev A token holder contract that will allow a beneficiary to extract the
@@ -12,7 +12,7 @@ import "../../Initializable.sol";
  * Useful for simple vesting schedules like "advisors get all of their tokens
  * after 1 year".
  */
-contract TokenTimelockUpgradeSafe is __Initializable {
+contract TokenTimelockUpgradeSafe is Initializable {
     using SafeERC20UpgradeSafe for IERC20UpgradeSafe;
 
     // ERC20 basic token contract being held
@@ -24,11 +24,11 @@ contract TokenTimelockUpgradeSafe is __Initializable {
     // timestamp when token release is enabled
     uint256 private _releaseTime;
 
-    function __TokenTimelock_init(IERC20UpgradeSafe token, address beneficiary, uint256 releaseTime) internal __initializer {
+    function __TokenTimelock_init(IERC20UpgradeSafe token, address beneficiary, uint256 releaseTime) internal initializer {
         __TokenTimelock_init_unchained(token, beneficiary, releaseTime);
     }
 
-    function __TokenTimelock_init_unchained(IERC20UpgradeSafe token, address beneficiary, uint256 releaseTime) internal __initializer {
+    function __TokenTimelock_init_unchained(IERC20UpgradeSafe token, address beneficiary, uint256 releaseTime) internal initializer {
         // solhint-disable-next-line not-rely-on-time
         require(releaseTime > block.timestamp, "TokenTimelock: release time is before current time");
         _token = token;

contracts/token/ERC721/ERC721BurnableUpgradeSafe.sol

@@ -4,20 +4,20 @@ pragma solidity ^0.6.0;
 
 import "../../GSN/ContextUpgradeSafe.sol";
 import "./ERC721UpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @title ERC721 Burnable Token
  * @dev ERC721 Token that can be irreversibly burned (destroyed).
  */
-abstract contract ERC721BurnableUpgradeSafe is __Initializable, ContextUpgradeSafe, ERC721UpgradeSafe {
-    function __ERC721Burnable_init() internal __initializer {
+abstract contract ERC721BurnableUpgradeSafe is Initializable, ContextUpgradeSafe, ERC721UpgradeSafe {
+    function __ERC721Burnable_init() internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC721Burnable_init_unchained();
     }
 
-    function __ERC721Burnable_init_unchained() internal __initializer {
+    function __ERC721Burnable_init_unchained() internal initializer {
     }
     /**
      * @dev Burns `tokenId`. See {ERC721-_burn}.

contracts/token/ERC721/ERC721HolderUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "./IERC721ReceiverUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
   /**
    * @dev Implementation of the {IERC721Receiver} interface.
@@ -11,12 +11,12 @@ import "../../Initializable.sol";
    * Accepts all token transfers. 
    * Make sure the contract is able to use its token with {IERC721-safeTransferFrom}, {IERC721-approve} or {IERC721-setApprovalForAll}.
    */
-contract ERC721HolderUpgradeSafe is __Initializable, IERC721ReceiverUpgradeSafe {
-    function __ERC721Holder_init() internal __initializer {
+contract ERC721HolderUpgradeSafe is Initializable, IERC721ReceiverUpgradeSafe {
+    function __ERC721Holder_init() internal initializer {
         __ERC721Holder_init_unchained();
     }
 
-    function __ERC721Holder_init_unchained() internal __initializer {
+    function __ERC721Holder_init_unchained() internal initializer {
     }
 
     /**

contracts/token/ERC721/ERC721PausableUpgradeSafe.sol

@@ -4,7 +4,7 @@ pragma solidity ^0.6.0;
 
 import "./ERC721UpgradeSafe.sol";
 import "../../utils/PausableUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev ERC721 token with pausable token transfers, minting and burning.
@@ -13,15 +13,15 @@ import "../../Initializable.sol";
  * period, or having an emergency switch for freezing all token transfers in the
  * event of a large bug.
  */
-abstract contract ERC721PausableUpgradeSafe is __Initializable, ERC721UpgradeSafe, PausableUpgradeSafe {
-    function __ERC721Pausable_init() internal __initializer {
+abstract contract ERC721PausableUpgradeSafe is Initializable, ERC721UpgradeSafe, PausableUpgradeSafe {
+    function __ERC721Pausable_init() internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __Pausable_init_unchained();
         __ERC721Pausable_init_unchained();
     }
 
-    function __ERC721Pausable_init_unchained() internal __initializer {
+    function __ERC721Pausable_init_unchained() internal initializer {
     }
     /**
      * @dev See {ERC721-_beforeTokenTransfer}.

contracts/token/ERC721/ERC721UpgradeSafe.sol

@@ -13,13 +13,13 @@ import "../../utils/AddressUpgradeSafe.sol";
 import "../../utils/EnumerableSetUpgradeSafe.sol";
 import "../../utils/EnumerableMapUpgradeSafe.sol";
 import "../../utils/StringsUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @title ERC721 Non-Fungible Token Standard basic implementation
  * @dev see https://eips.ethereum.org/EIPS/eip-721
  */
-contract ERC721UpgradeSafe is __Initializable, ContextUpgradeSafe, ERC165UpgradeSafe, IERC721UpgradeSafe, IERC721MetadataUpgradeSafe, IERC721EnumerableUpgradeSafe {
+contract ERC721UpgradeSafe is Initializable, ContextUpgradeSafe, ERC165UpgradeSafe, IERC721UpgradeSafe, IERC721MetadataUpgradeSafe, IERC721EnumerableUpgradeSafe {
     using SafeMathUpgradeSafe for uint256;
     using AddressUpgradeSafe for address;
     using EnumerableSetUpgradeSafe for EnumerableSetUpgradeSafe.UintSet;
@@ -91,13 +91,13 @@ contract ERC721UpgradeSafe is __Initializable, ContextUpgradeSafe, ERC165Upgrade
     /**
      * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
      */
-    function __ERC721_init(string memory name, string memory symbol) internal __initializer {
+    function __ERC721_init(string memory name, string memory symbol) internal initializer {
         __Context_init_unchained();
         __ERC165_init_unchained();
         __ERC721_init_unchained(name, symbol);
     }
 
-    function __ERC721_init_unchained(string memory name, string memory symbol) internal __initializer {
+    function __ERC721_init_unchained(string memory name, string memory symbol) internal initializer {
         _name = name;
         _symbol = symbol;
 

contracts/token/ERC777/ERC777UpgradeSafe.sol

@@ -10,7 +10,7 @@ import "../../token/ERC20/IERC20UpgradeSafe.sol";
 import "../../math/SafeMathUpgradeSafe.sol";
 import "../../utils/AddressUpgradeSafe.sol";
 import "../../introspection/IERC1820RegistryUpgradeSafe.sol";
-import "../../Initializable.sol";
+import "../../proxy/Initializable.sol";
 
 /**
  * @dev Implementation of the {IERC777} interface.
@@ -27,7 +27,7 @@ import "../../Initializable.sol";
  * are no special restrictions in the amount of tokens that created, moved, or
  * destroyed. This makes integration with ERC20 applications seamless.
  */
-contract ERC777UpgradeSafe is __Initializable, ContextUpgradeSafe, IERC777UpgradeSafe, IERC20UpgradeSafe {
+contract ERC777UpgradeSafe is Initializable, ContextUpgradeSafe, IERC777UpgradeSafe, IERC20UpgradeSafe {
     using SafeMathUpgradeSafe for uint256;
     using AddressUpgradeSafe for address;
 
@@ -71,7 +71,7 @@ contract ERC777UpgradeSafe is __Initializable, ContextUpgradeSafe, IERC777Upgrad
         string memory name,
         string memory symbol,
         address[] memory defaultOperators
-    ) internal __initializer {
+    ) internal initializer {
         __Context_init_unchained();
         __ERC777_init_unchained(name, symbol, defaultOperators);
     }
@@ -80,7 +80,7 @@ contract ERC777UpgradeSafe is __Initializable, ContextUpgradeSafe, IERC777Upgrad
         string memory name,
         string memory symbol,
         address[] memory defaultOperators
-    ) internal __initializer {
+    ) internal initializer {
         _name = name;
         _symbol = symbol;
 

contracts/utils/PausableUpgradeSafe.sol

@@ -3,7 +3,7 @@
 pragma solidity ^0.6.0;
 
 import "../GSN/ContextUpgradeSafe.sol";
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Contract module which allows children to implement an emergency stop
@@ -14,7 +14,7 @@ import "../Initializable.sol";
  * the functions of your contract. Note that they will not be pausable by
  * simply including this module, only once the modifiers are put in place.
  */
-contract PausableUpgradeSafe is __Initializable, ContextUpgradeSafe {
+contract PausableUpgradeSafe is Initializable, ContextUpgradeSafe {
     /**
      * @dev Emitted when the pause is triggered by `account`.
      */
@@ -30,12 +30,12 @@ contract PausableUpgradeSafe is __Initializable, ContextUpgradeSafe {
     /**
      * @dev Initializes the contract in unpaused state.
      */
-    function __Pausable_init() internal __initializer {
+    function __Pausable_init() internal initializer {
         __Context_init_unchained();
         __Pausable_init_unchained();
     }
 
-    function __Pausable_init_unchained() internal __initializer {
+    function __Pausable_init_unchained() internal initializer {
         _paused = false;
     }
 

contracts/utils/ReentrancyGuardUpgradeSafe.sol

 // SPDX-License-Identifier: MIT
 
 pragma solidity ^0.6.0;
-import "../Initializable.sol";
+import "../proxy/Initializable.sol";
 
 /**
  * @dev Contract module that helps prevent reentrant calls to a function.
@@ -19,7 +19,7 @@ import "../Initializable.sol";
  * to protect against it, check out our blog post
  * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
  */
-contract ReentrancyGuardUpgradeSafe is __Initializable {
+contract ReentrancyGuardUpgradeSafe is Initializable {
     // Booleans are more expensive than uint256 or any type that takes up a full
     // word because each write operation emits an extra SLOAD to first read the
     // slot's contents, replace the bits taken up by the boolean, and then write
@@ -36,11 +36,11 @@ contract ReentrancyGuardUpgradeSafe is __Initializable {
 
     uint256 private _status;
 
-    function __ReentrancyGuard_init() internal __initializer {
+    function __ReentrancyGuard_init() internal initializer {
         __ReentrancyGuard_init_unchained();
     }
 
-    function __ReentrancyGuard_init_unchained() internal __initializer {
+    function __ReentrancyGuard_init_unchained() internal initializer {
         _status = _NOT_ENTERED;
     }
 

scripts/transpile.sh

@@ -4,4 +4,7 @@ set -euo pipefail -x
 
 npm run compile
 
-npx @openzeppelin/upgrade-safe-transpiler -D
+# -D: delete original and excluded files
+# -i: use included Initializable
+# -x: exclude all proxy contracts
+npx @openzeppelin/upgrade-safe-transpiler -D -i contracts/proxy/Initializable.sol -x 'contracts/proxy/**/*'