Use caret for peer dependency

* Change import path from zos-lib to upgrades in all contracts

* Update readme with new naming

* Update package and deps names

* Change path to initializable in AST of networks.jsons

* Migrate manifest version

* Use new oz file locations

* Rename in ERC20Migrator comments

* Update SDK install instructions in README

* Update gitignore to use new session file name

* trigger CI

* Fixes to readme and package version

* Use 2.5.0 release of OpenZeppelin SDK

.gitignore

@@ -38,5 +38,7 @@ build/
 # truffle
 .node-xmlhttprequest-*
 
+.openzeppelin/.session
+
 # IntelliJ IDE
 .idea

.openzeppelin/kovan.json

@@ -0,0 +1,945 @@
+{
+  "contracts": {
+    "TokenVesting": {
+      "address": "0x17d2e73611a9ec10ab4751c514a539ec820b953c",
+      "constructorCode": "608060405234801561001057600080fd5b50611c6c806100206000396000f3fe",
+      "bodyBytecodeHash": "ba0eade6a19e4b485aca3478c8755d2a6041a2b39a7aa1a0a73253a782c4a065",
+      "localBytecodeHash": "94b5eed89a6bab268326a5010e52000ff74d40d96c83811c9d455d7c8b54f447",
+      "deployedBytecodeHash": "94b5eed89a6bab268326a5010e52000ff74d40d96c83811c9d455d7c8b54f447",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 8198,
+          "type": "t_address",
+          "src": "472:22:108"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 8311,
+          "type": "t_array:50<t_uint256>",
+          "src": "2415:29:108"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 3576,
+          "type": "t_address",
+          "src": "1133:28:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 3578,
+          "type": "t_uint256",
+          "src": "1263:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 3580,
+          "type": "t_uint256",
+          "src": "1291:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 3582,
+          "type": "t_uint256",
+          "src": "1319:25:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 3584,
+          "type": "t_bool",
+          "src": "1351:23:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 3588,
+          "type": "t_mapping<t_uint256>",
+          "src": "1381:46:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 3592,
+          "type": "t_mapping<t_bool>",
+          "src": "1433:42:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 3941,
+          "type": "t_array:50<t_uint256>",
+          "src": "6226:29:28"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0xf1e274980871d7c4aaab8d646c17728ed263e747",
+      "constructorCode": "608060405234801561001057600080fd5b506110a4806100206000396000f3fe",
+      "bodyBytecodeHash": "fe0f9da480efb9ef366284126f8d9dccff6f19f8ee0183449035b37c1f5103d8",
+      "localBytecodeHash": "d9901040952d3add936b2939fb694875bdfd7b513c877bc1942d36a5e4190873",
+      "deployedBytecodeHash": "d9901040952d3add936b2939fb694875bdfd7b513c877bc1942d36a5e4190873",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_array:dyn<t_address>": {
+          "id": "t_array:dyn<t_address>",
+          "valueType": "t_address",
+          "length": "dyn",
+          "kind": "array",
+          "label": "address[]"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 8418,
+          "type": "t_uint256",
+          "src": "1176:28:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 8420,
+          "type": "t_uint256",
+          "src": "1210:30:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 8424,
+          "type": "t_mapping<t_uint256>",
+          "src": "1247:43:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 8428,
+          "type": "t_mapping<t_uint256>",
+          "src": "1296:45:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 8431,
+          "type": "t_array:dyn<t_address>",
+          "src": "1347:25:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 8684,
+          "type": "t_array:50<t_uint256>",
+          "src": "5158:29:110"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0x2a79d89665d22ee56cc0efd102169fa41f27b065",
+      "constructorCode": "608060405234801561001057600080fd5b50613153806100206000396000f3fe",
+      "bodyBytecodeHash": "ad8d45945d6a4f088a61fd605c38cdf2f40171624bca2a7c3b2d4e95b068eb3d",
+      "localBytecodeHash": "bca15bc1a7aa87c603c9b185aab38e0d72b8adc6347426bb66954cef39e88a74",
+      "deployedBytecodeHash": "bca15bc1a7aa87c603c9b185aab38e0d72b8adc6347426bb66954cef39e88a74",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_uint8": {
+          "id": "t_uint8",
+          "kind": "elementary",
+          "label": "uint8"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 9641,
+          "type": "t_string",
+          "src": "209:20:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 9643,
+          "type": "t_string",
+          "src": "235:22:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 9645,
+          "type": "t_uint8",
+          "src": "263:23:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 9697,
+          "type": "t_array:50<t_uint256>",
+          "src": "1645:29:118"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 9129,
+          "type": "t_mapping<t_uint256>",
+          "src": "1357:46:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 9135,
+          "type": "t_mapping<t_uint256>",
+          "src": "1410:69:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 9137,
+          "type": "t_uint256",
+          "src": "1486:28:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 9516,
+          "type": "t_array:50<t_uint256>",
+          "src": "7875:29:115"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 219,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 319,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:2"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 9746,
+          "type": "t_array:50<t_uint256>",
+          "src": "816:29:119"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 339,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 439,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4481,
+          "type": "t_bool",
+          "src": "855:20:37"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4564,
+          "type": "t_array:50<t_uint256>",
+          "src": "2105:29:37"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 9869,
+          "type": "t_array:50<t_uint256>",
+          "src": "1178:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 219,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:2"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 339,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:3"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 9135,
+              "type": "t_mapping<t_uint256>",
+              "src": "1410:69:115"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 8173,
+              "type": "t_mapping<t_uint256>",
+              "src": "827:66:110"
+            }
+          }
+        ]
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0x61e5b805911ba82de487e13de1e375a6130004f0",
+      "constructorCode": "608060405234801561001057600080fd5b50614299806100206000396000f3fe",
+      "bodyBytecodeHash": "9113153cb4b2b62f720cb12960ba3b4a7b9a5f3329e34a4a3ece0212d130ae53",
+      "localBytecodeHash": "5dca693db1fee9a4ce973e49d6665a8770b823c36ba2c7e64f37d81046672074",
+      "deployedBytecodeHash": "5dca693db1fee9a4ce973e49d6665a8770b823c36ba2c7e64f37d81046672074",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_address>": {
+          "id": "t_mapping<t_address>",
+          "valueType": "t_address",
+          "label": "mapping(key => address)",
+          "kind": "mapping"
+        },
+        "t_struct<Counters.Counter>": {
+          "id": "t_struct<Counters.Counter>",
+          "kind": "struct",
+          "label": "Counters.Counter",
+          "members": [
+            {
+              "label": "_value",
+              "astId": 2533,
+              "type": "t_uint256",
+              "src": "1022:14:22"
+            }
+          ]
+        },
+        "t_mapping<t_struct<Counters.Counter>>": {
+          "id": "t_mapping<t_struct<Counters.Counter>>",
+          "valueType": "t_struct<Counters.Counter>",
+          "label": "mapping(key => Counters.Counter)",
+          "kind": "mapping"
+        },
+        "t_array:dyn<t_uint256>": {
+          "id": "t_array:dyn<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "dyn",
+          "kind": "array",
+          "label": "uint256[]"
+        },
+        "t_mapping<t_array:dyn<t_uint256>>": {
+          "id": "t_mapping<t_array:dyn<t_uint256>>",
+          "valueType": "t_array:dyn<t_uint256>",
+          "label": "mapping(key => uint256[])",
+          "kind": "mapping"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_mapping<t_string>": {
+          "id": "t_mapping<t_string>",
+          "valueType": "t_string",
+          "label": "mapping(key => string)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 4117,
+          "type": "t_mapping<t_bool>",
+          "src": "550:52:31"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 4162,
+          "type": "t_array:50<t_uint256>",
+          "src": "1714:29:31"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 10508,
+          "type": "t_mapping<t_address>",
+          "src": "829:48:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 10512,
+          "type": "t_mapping<t_address>",
+          "src": "933:52:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 10516,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1043:63:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 10522,
+          "type": "t_mapping<t_bool>",
+          "src": "1161:73:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 11065,
+          "type": "t_array:50<t_uint256>",
+          "src": "12696:29:125"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 11117,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "445:50:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 11121,
+          "type": "t_mapping<t_uint256>",
+          "src": "565:53:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 11124,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "679:28:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 11128,
+          "type": "t_mapping<t_uint256>",
+          "src": "778:51:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 11459,
+          "type": "t_array:50<t_uint256>",
+          "src": "8994:29:127"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 11526,
+          "type": "t_string",
+          "src": "266:20:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 11528,
+          "type": "t_string",
+          "src": "313:22:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 11532,
+          "type": "t_mapping<t_string>",
+          "src": "381:45:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 11663,
+          "type": "t_array:50<t_uint256>",
+          "src": "3029:29:130"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 219,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 319,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:2"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 11733,
+          "type": "t_array:50<t_uint256>",
+          "src": "1042:29:131"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 339,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 439,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4481,
+          "type": "t_bool",
+          "src": "855:20:37"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4564,
+          "type": "t_array:50<t_uint256>",
+          "src": "2105:29:37"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 11878,
+          "type": "t_array:50<t_uint256>",
+          "src": "850:29:133"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 10516,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1043:63:125"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 219,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:2"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 339,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:3"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "typechange",
+            "updated": {
+              "index": 7,
+              "contract": "ERC721",
+              "path": "contracts/token/ERC721/ERC721.sol",
+              "label": "_ownedTokensCount",
+              "astId": 10516,
+              "type": "t_mapping<t_struct<Counters.Counter>>",
+              "src": "1043:63:125"
+            },
+            "original": {
+              "index": 7,
+              "contract": "ERC721",
+              "path": "contracts/token/ERC721/ERC721.sol",
+              "label": "_ownedTokensCount",
+              "astId": 9505,
+              "type": "t_mapping<t_uint256>",
+              "src": "988:54:120"
+            }
+          }
+        ]
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0xf5829d56998ccc1405b7eabccac78164af270d39"
+  },
+  "package": {
+    "address": "0xb6f8f11b166d526932ee04ffe4d25b810f619e34"
+  },
+  "provider": {
+    "address": "0x200194fd3013c88ab2b3c84e2c885aba42a3df5d"
+  },
+  "version": "2.2.0"
+}

.openzeppelin/mainnet.json

@@ -0,0 +1,851 @@
+{
+  "contracts": {
+    "StandaloneERC721": {
+      "address": "0x8c9900276e5eD54C104d743a6E01B7041acab40f",
+      "constructorCode": "608060405234801561001057600080fd5b506136c6806100206000396000f3fe",
+      "bodyBytecodeHash": "1f3ce589a0ba1fad4f98754bd97f051852e7dbb5522d49a7185defb3e377d347",
+      "localBytecodeHash": "84a5a6731b4686c34ef5acfcf4474af2e61b3e4e0b10ea96418e4b7bd1074cbc",
+      "deployedBytecodeHash": "84a5a6731b4686c34ef5acfcf4474af2e61b3e4e0b10ea96418e4b7bd1074cbc",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_address>": {
+          "id": "t_mapping<t_address>",
+          "valueType": "t_address",
+          "label": "mapping(key => address)",
+          "kind": "mapping"
+        },
+        "t_struct<Counters.Counter>": {
+          "id": "t_struct<Counters.Counter>",
+          "kind": "struct",
+          "label": "Counters.Counter",
+          "members": [
+            {
+              "label": "_value",
+              "astId": 2415,
+              "type": "t_uint256",
+              "src": "1021:14:22"
+            }
+          ]
+        },
+        "t_mapping<t_struct<Counters.Counter>>": {
+          "id": "t_mapping<t_struct<Counters.Counter>>",
+          "valueType": "t_struct<Counters.Counter>",
+          "label": "mapping(key => Counters.Counter)",
+          "kind": "mapping"
+        },
+        "t_array:dyn<t_uint256>": {
+          "id": "t_array:dyn<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "dyn",
+          "kind": "array",
+          "label": "uint256[]"
+        },
+        "t_mapping<t_array:dyn<t_uint256>>": {
+          "id": "t_mapping<t_array:dyn<t_uint256>>",
+          "valueType": "t_array:dyn<t_uint256>",
+          "label": "mapping(key => uint256[])",
+          "kind": "mapping"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_mapping<t_string>": {
+          "id": "t_mapping<t_string>",
+          "valueType": "t_string",
+          "label": "mapping(key => string)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 11836,
+          "type": "t_bool",
+          "src": "757:24:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 11838,
+          "type": "t_bool",
+          "src": "876:25:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 11887,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:140"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 3974,
+          "type": "t_mapping<t_bool>",
+          "src": "496:52:31"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 4018,
+          "type": "t_array:50<t_uint256>",
+          "src": "1229:29:31"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 10031,
+          "type": "t_mapping<t_address>",
+          "src": "829:48:122"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 10035,
+          "type": "t_mapping<t_address>",
+          "src": "933:52:122"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 10039,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1043:63:122"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 10045,
+          "type": "t_mapping<t_bool>",
+          "src": "1161:73:122"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 10568,
+          "type": "t_array:50<t_uint256>",
+          "src": "11658:29:122"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 10619,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "445:50:124"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 10623,
+          "type": "t_mapping<t_uint256>",
+          "src": "565:53:124"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 10626,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "679:28:124"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 10630,
+          "type": "t_mapping<t_uint256>",
+          "src": "778:51:124"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 10959,
+          "type": "t_array:50<t_uint256>",
+          "src": "8801:29:124"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 11026,
+          "type": "t_string",
+          "src": "266:20:127"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 11028,
+          "type": "t_string",
+          "src": "313:22:127"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 11032,
+          "type": "t_mapping<t_string>",
+          "src": "381:45:127"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 11161,
+          "type": "t_array:50<t_uint256>",
+          "src": "2834:29:127"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 231,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 330,
+          "type": "t_array:50<t_uint256>",
+          "src": "1081:29:2"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 11231,
+          "type": "t_array:50<t_uint256>",
+          "src": "1040:29:128"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 350,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 449,
+          "type": "t_array:50<t_uint256>",
+          "src": "1081:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4184,
+          "type": "t_bool",
+          "src": "352:20:34"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4265,
+          "type": "t_array:50<t_uint256>",
+          "src": "1429:29:34"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 11376,
+          "type": "t_array:50<t_uint256>",
+          "src": "850:29:130"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0xe95Ca7dE499b425FBbdFD08C4021448FAB91cB0D",
+      "constructorCode": "608060405234801561001057600080fd5b50612904806100206000396000f3fe",
+      "bodyBytecodeHash": "68b813a3c2b5407b02238fdd29abedd7efa8d2e88e3aecea30ca59ad3cafa465",
+      "localBytecodeHash": "ffcdfe04a4bf5020bb4661355d65a2d6da2938f1070399f417f8fc8d301ea692",
+      "deployedBytecodeHash": "ffcdfe04a4bf5020bb4661355d65a2d6da2938f1070399f417f8fc8d301ea692",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_uint8": {
+          "id": "t_uint8",
+          "kind": "elementary",
+          "label": "uint8"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 11836,
+          "type": "t_bool",
+          "src": "757:24:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 11838,
+          "type": "t_bool",
+          "src": "876:25:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 11887,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:140"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 9171,
+          "type": "t_string",
+          "src": "382:20:115"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 9173,
+          "type": "t_string",
+          "src": "408:22:115"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 9175,
+          "type": "t_uint8",
+          "src": "436:23:115"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 9227,
+          "type": "t_array:50<t_uint256>",
+          "src": "1097:29:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 8675,
+          "type": "t_mapping<t_uint256>",
+          "src": "752:46:112"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowed",
+          "astId": 8681,
+          "type": "t_mapping<t_uint256>",
+          "src": "805:66:112"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 8683,
+          "type": "t_uint256",
+          "src": "878:28:112"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 9048,
+          "type": "t_array:50<t_uint256>",
+          "src": "7714:29:112"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 231,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 330,
+          "type": "t_array:50<t_uint256>",
+          "src": "1081:29:2"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 9276,
+          "type": "t_array:50<t_uint256>",
+          "src": "745:29:116"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 350,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 449,
+          "type": "t_array:50<t_uint256>",
+          "src": "1081:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4184,
+          "type": "t_bool",
+          "src": "352:20:34"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4265,
+          "type": "t_array:50<t_uint256>",
+          "src": "1429:29:34"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 9399,
+          "type": "t_array:50<t_uint256>",
+          "src": "1194:29:117"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0xb3E46068440Ebd9AD43A3347eDFfC63697B84544",
+      "constructorCode": "608060405234801561001057600080fd5b50610c17806100206000396000f3fe",
+      "bodyBytecodeHash": "34c5c6011ba90548e55bf061f25c0847894d8882e4fa691726bf5d70bfadfd70",
+      "localBytecodeHash": "d2ee04ff44581e396d308fb7e8f6ff66680f1eda86ee165873c4c16a65b4269d",
+      "deployedBytecodeHash": "d2ee04ff44581e396d308fb7e8f6ff66680f1eda86ee165873c4c16a65b4269d",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_array:dyn<t_address>": {
+          "id": "t_array:dyn<t_address>",
+          "valueType": "t_address",
+          "length": "dyn",
+          "kind": "array",
+          "label": "address[]"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 11836,
+          "type": "t_bool",
+          "src": "757:24:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 11838,
+          "type": "t_bool",
+          "src": "876:25:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 11887,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:140"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 7977,
+          "type": "t_uint256",
+          "src": "540:28:107"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 7979,
+          "type": "t_uint256",
+          "src": "574:30:107"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 7983,
+          "type": "t_mapping<t_uint256>",
+          "src": "611:43:107"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 7987,
+          "type": "t_mapping<t_uint256>",
+          "src": "660:45:107"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 7990,
+          "type": "t_array:dyn<t_address>",
+          "src": "711:25:107"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 8236,
+          "type": "t_array:50<t_uint256>",
+          "src": "3236:29:107"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    },
+    "TokenVesting": {
+      "address": "0xF0fcf1a5aaf25CDe77cb6ef95717323FAEfE492d",
+      "constructorCode": "608060405234801561001057600080fd5b50611559806100206000396000f3fe",
+      "bodyBytecodeHash": "01f22f428367f86242e342322247e732d645b5cfdd40a9411cb3a10842ee2bac",
+      "localBytecodeHash": "f5eb9bf4cd80d75f1e0928674f0436601837641bdbc0196a89f8ea392097a282",
+      "deployedBytecodeHash": "f5eb9bf4cd80d75f1e0928674f0436601837641bdbc0196a89f8ea392097a282",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 11836,
+          "type": "t_bool",
+          "src": "757:24:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 11838,
+          "type": "t_bool",
+          "src": "876:25:140"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 11887,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:140"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 7761,
+          "type": "t_address",
+          "src": "302:22:105"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 7872,
+          "type": "t_array:50<t_uint256>",
+          "src": "2262:29:105"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 3441,
+          "type": "t_address",
+          "src": "1133:28:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 3443,
+          "type": "t_uint256",
+          "src": "1263:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 3445,
+          "type": "t_uint256",
+          "src": "1291:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 3447,
+          "type": "t_uint256",
+          "src": "1319:25:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 3449,
+          "type": "t_bool",
+          "src": "1351:23:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 3453,
+          "type": "t_mapping<t_uint256>",
+          "src": "1381:46:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 3457,
+          "type": "t_mapping<t_bool>",
+          "src": "1433:42:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 3799,
+          "type": "t_array:50<t_uint256>",
+          "src": "5837:29:28"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x2Ba1a8C7352a5B5Ea3ea3408F89e1bA7920d36CE"
+  },
+  "package": {
+    "address": "0x778dddF23Ec1B5Cb18394c6C110480CaaDB3B0f6"
+  },
+  "provider": {
+    "address": "0xdd3e0B83e5462FD4Ba012FF05A57f709FA050458"
+  },
+  "version": "2.2.0"
+}

.openzeppelin/project.json

@@ -0,0 +1,12 @@
+{
+  "manifestVersion": "2.2",
+  "name": "@openzeppelin/contracts-ethereum-package",
+  "publish": true,
+  "version": "2.2.0",
+  "contracts": {
+    "StandaloneERC20": "StandaloneERC20",
+    "StandaloneERC721": "StandaloneERC721",
+    "TokenVesting": "TokenVesting",
+    "PaymentSplitter": "PaymentSplitter"
+  }
+}

.openzeppelin/rinkeby.json

@@ -0,0 +1,945 @@
+{
+  "contracts": {
+    "PaymentSplitter": {
+      "address": "0x29d58ac2407f62caf9b1e00f0d7088d8c8590703",
+      "constructorCode": "608060405234801561001057600080fd5b506110a4806100206000396000f3fe",
+      "bodyBytecodeHash": "fe0f9da480efb9ef366284126f8d9dccff6f19f8ee0183449035b37c1f5103d8",
+      "localBytecodeHash": "d9901040952d3add936b2939fb694875bdfd7b513c877bc1942d36a5e4190873",
+      "deployedBytecodeHash": "d9901040952d3add936b2939fb694875bdfd7b513c877bc1942d36a5e4190873",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_array:dyn<t_address>": {
+          "id": "t_array:dyn<t_address>",
+          "valueType": "t_address",
+          "length": "dyn",
+          "kind": "array",
+          "label": "address[]"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 8418,
+          "type": "t_uint256",
+          "src": "1176:28:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 8420,
+          "type": "t_uint256",
+          "src": "1210:30:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 8424,
+          "type": "t_mapping<t_uint256>",
+          "src": "1247:43:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 8428,
+          "type": "t_mapping<t_uint256>",
+          "src": "1296:45:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 8431,
+          "type": "t_array:dyn<t_address>",
+          "src": "1347:25:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 8684,
+          "type": "t_array:50<t_uint256>",
+          "src": "5158:29:110"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "TokenVesting": {
+      "address": "0x142e4ad09777e6f3068e630a085a4739614d1e76",
+      "constructorCode": "608060405234801561001057600080fd5b50611c6c806100206000396000f3fe",
+      "bodyBytecodeHash": "ba0eade6a19e4b485aca3478c8755d2a6041a2b39a7aa1a0a73253a782c4a065",
+      "localBytecodeHash": "94b5eed89a6bab268326a5010e52000ff74d40d96c83811c9d455d7c8b54f447",
+      "deployedBytecodeHash": "94b5eed89a6bab268326a5010e52000ff74d40d96c83811c9d455d7c8b54f447",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 8198,
+          "type": "t_address",
+          "src": "472:22:108"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 8311,
+          "type": "t_array:50<t_uint256>",
+          "src": "2415:29:108"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 3576,
+          "type": "t_address",
+          "src": "1133:28:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 3578,
+          "type": "t_uint256",
+          "src": "1263:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 3580,
+          "type": "t_uint256",
+          "src": "1291:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 3582,
+          "type": "t_uint256",
+          "src": "1319:25:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 3584,
+          "type": "t_bool",
+          "src": "1351:23:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 3588,
+          "type": "t_mapping<t_uint256>",
+          "src": "1381:46:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 3592,
+          "type": "t_mapping<t_bool>",
+          "src": "1433:42:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 3941,
+          "type": "t_array:50<t_uint256>",
+          "src": "6226:29:28"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0xa17887b5aacc4d3b04ae375178d8e0971d84434a",
+      "constructorCode": "608060405234801561001057600080fd5b50613153806100206000396000f3fe",
+      "bodyBytecodeHash": "ad8d45945d6a4f088a61fd605c38cdf2f40171624bca2a7c3b2d4e95b068eb3d",
+      "localBytecodeHash": "bca15bc1a7aa87c603c9b185aab38e0d72b8adc6347426bb66954cef39e88a74",
+      "deployedBytecodeHash": "bca15bc1a7aa87c603c9b185aab38e0d72b8adc6347426bb66954cef39e88a74",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_uint8": {
+          "id": "t_uint8",
+          "kind": "elementary",
+          "label": "uint8"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 9641,
+          "type": "t_string",
+          "src": "209:20:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 9643,
+          "type": "t_string",
+          "src": "235:22:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 9645,
+          "type": "t_uint8",
+          "src": "263:23:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 9697,
+          "type": "t_array:50<t_uint256>",
+          "src": "1645:29:118"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 9129,
+          "type": "t_mapping<t_uint256>",
+          "src": "1357:46:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 9135,
+          "type": "t_mapping<t_uint256>",
+          "src": "1410:69:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 9137,
+          "type": "t_uint256",
+          "src": "1486:28:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 9516,
+          "type": "t_array:50<t_uint256>",
+          "src": "7875:29:115"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 219,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 319,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:2"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 9746,
+          "type": "t_array:50<t_uint256>",
+          "src": "816:29:119"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 339,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 439,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4481,
+          "type": "t_bool",
+          "src": "855:20:37"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4564,
+          "type": "t_array:50<t_uint256>",
+          "src": "2105:29:37"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 9869,
+          "type": "t_array:50<t_uint256>",
+          "src": "1178:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 219,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:2"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 339,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:3"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 9135,
+              "type": "t_mapping<t_uint256>",
+              "src": "1410:69:115"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 8173,
+              "type": "t_mapping<t_uint256>",
+              "src": "827:66:110"
+            }
+          }
+        ]
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0x27787a3b782897021eaffb8f1d52e71d74cea0b0",
+      "constructorCode": "608060405234801561001057600080fd5b50614299806100206000396000f3fe",
+      "bodyBytecodeHash": "9113153cb4b2b62f720cb12960ba3b4a7b9a5f3329e34a4a3ece0212d130ae53",
+      "localBytecodeHash": "5dca693db1fee9a4ce973e49d6665a8770b823c36ba2c7e64f37d81046672074",
+      "deployedBytecodeHash": "5dca693db1fee9a4ce973e49d6665a8770b823c36ba2c7e64f37d81046672074",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_address>": {
+          "id": "t_mapping<t_address>",
+          "valueType": "t_address",
+          "label": "mapping(key => address)",
+          "kind": "mapping"
+        },
+        "t_struct<Counters.Counter>": {
+          "id": "t_struct<Counters.Counter>",
+          "kind": "struct",
+          "label": "Counters.Counter",
+          "members": [
+            {
+              "label": "_value",
+              "astId": 2533,
+              "type": "t_uint256",
+              "src": "1022:14:22"
+            }
+          ]
+        },
+        "t_mapping<t_struct<Counters.Counter>>": {
+          "id": "t_mapping<t_struct<Counters.Counter>>",
+          "valueType": "t_struct<Counters.Counter>",
+          "label": "mapping(key => Counters.Counter)",
+          "kind": "mapping"
+        },
+        "t_array:dyn<t_uint256>": {
+          "id": "t_array:dyn<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "dyn",
+          "kind": "array",
+          "label": "uint256[]"
+        },
+        "t_mapping<t_array:dyn<t_uint256>>": {
+          "id": "t_mapping<t_array:dyn<t_uint256>>",
+          "valueType": "t_array:dyn<t_uint256>",
+          "label": "mapping(key => uint256[])",
+          "kind": "mapping"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_mapping<t_string>": {
+          "id": "t_mapping<t_string>",
+          "valueType": "t_string",
+          "label": "mapping(key => string)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 4117,
+          "type": "t_mapping<t_bool>",
+          "src": "550:52:31"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 4162,
+          "type": "t_array:50<t_uint256>",
+          "src": "1714:29:31"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 10508,
+          "type": "t_mapping<t_address>",
+          "src": "829:48:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 10512,
+          "type": "t_mapping<t_address>",
+          "src": "933:52:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 10516,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1043:63:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 10522,
+          "type": "t_mapping<t_bool>",
+          "src": "1161:73:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 11065,
+          "type": "t_array:50<t_uint256>",
+          "src": "12696:29:125"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 11117,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "445:50:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 11121,
+          "type": "t_mapping<t_uint256>",
+          "src": "565:53:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 11124,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "679:28:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 11128,
+          "type": "t_mapping<t_uint256>",
+          "src": "778:51:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 11459,
+          "type": "t_array:50<t_uint256>",
+          "src": "8994:29:127"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 11526,
+          "type": "t_string",
+          "src": "266:20:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 11528,
+          "type": "t_string",
+          "src": "313:22:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 11532,
+          "type": "t_mapping<t_string>",
+          "src": "381:45:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 11663,
+          "type": "t_array:50<t_uint256>",
+          "src": "3029:29:130"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 219,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 319,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:2"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 11733,
+          "type": "t_array:50<t_uint256>",
+          "src": "1042:29:131"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 339,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 439,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4481,
+          "type": "t_bool",
+          "src": "855:20:37"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4564,
+          "type": "t_array:50<t_uint256>",
+          "src": "2105:29:37"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 11878,
+          "type": "t_array:50<t_uint256>",
+          "src": "850:29:133"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 10516,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1043:63:125"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 219,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:2"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 339,
+            "type": "t_struct<Roles.Role>",
+            "src": "271:27:3"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "typechange",
+            "updated": {
+              "index": 7,
+              "contract": "ERC721",
+              "path": "contracts/token/ERC721/ERC721.sol",
+              "label": "_ownedTokensCount",
+              "astId": 10516,
+              "type": "t_mapping<t_struct<Counters.Counter>>",
+              "src": "1043:63:125"
+            },
+            "original": {
+              "index": 7,
+              "contract": "ERC721",
+              "path": "contracts/token/ERC721/ERC721.sol",
+              "label": "_ownedTokensCount",
+              "astId": 9505,
+              "type": "t_mapping<t_uint256>",
+              "src": "988:54:120"
+            }
+          }
+        ]
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x291439e6444daec9e47ae359aa79fd1811a42679"
+  },
+  "package": {
+    "address": "0xa44bb80b290de8a465d17b14269df53cf0b9bf4f"
+  },
+  "provider": {
+    "address": "0x20b96704e5cab368fc05d8729b9d2c4c830f9338"
+  },
+  "version": "2.2.0"
+}

.openzeppelin/ropsten.json

@@ -0,0 +1,851 @@
+{
+  "contracts": {
+    "TokenVesting": {
+      "address": "0x37b52342e1e8eca924c69e49797e8b1a80251a88",
+      "constructorCode": "608060405234801561001057600080fd5b50611c6c806100206000396000f3fe",
+      "bodyBytecodeHash": "ba0eade6a19e4b485aca3478c8755d2a6041a2b39a7aa1a0a73253a782c4a065",
+      "localBytecodeHash": "94b5eed89a6bab268326a5010e52000ff74d40d96c83811c9d455d7c8b54f447",
+      "deployedBytecodeHash": "94b5eed89a6bab268326a5010e52000ff74d40d96c83811c9d455d7c8b54f447",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 8198,
+          "type": "t_address",
+          "src": "472:22:108"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 8311,
+          "type": "t_array:50<t_uint256>",
+          "src": "2415:29:108"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 3576,
+          "type": "t_address",
+          "src": "1133:28:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 3578,
+          "type": "t_uint256",
+          "src": "1263:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 3580,
+          "type": "t_uint256",
+          "src": "1291:22:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 3582,
+          "type": "t_uint256",
+          "src": "1319:25:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 3584,
+          "type": "t_bool",
+          "src": "1351:23:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 3588,
+          "type": "t_mapping<t_uint256>",
+          "src": "1381:46:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 3592,
+          "type": "t_mapping<t_bool>",
+          "src": "1433:42:28"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 3941,
+          "type": "t_array:50<t_uint256>",
+          "src": "6226:29:28"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0xee1ff7edb4d1dee795497dc715a8173c9ddda440",
+      "constructorCode": "608060405234801561001057600080fd5b506110a4806100206000396000f3fe",
+      "bodyBytecodeHash": "fe0f9da480efb9ef366284126f8d9dccff6f19f8ee0183449035b37c1f5103d8",
+      "localBytecodeHash": "d9901040952d3add936b2939fb694875bdfd7b513c877bc1942d36a5e4190873",
+      "deployedBytecodeHash": "d9901040952d3add936b2939fb694875bdfd7b513c877bc1942d36a5e4190873",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_array:dyn<t_address>": {
+          "id": "t_array:dyn<t_address>",
+          "valueType": "t_address",
+          "length": "dyn",
+          "kind": "array",
+          "label": "address[]"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 8418,
+          "type": "t_uint256",
+          "src": "1176:28:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 8420,
+          "type": "t_uint256",
+          "src": "1210:30:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 8424,
+          "type": "t_mapping<t_uint256>",
+          "src": "1247:43:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 8428,
+          "type": "t_mapping<t_uint256>",
+          "src": "1296:45:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 8431,
+          "type": "t_array:dyn<t_address>",
+          "src": "1347:25:110"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 8684,
+          "type": "t_array:50<t_uint256>",
+          "src": "5158:29:110"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0x2ed7f08736297d10dfa04a9b272dffc03615644f",
+      "constructorCode": "608060405234801561001057600080fd5b50613153806100206000396000f3fe",
+      "bodyBytecodeHash": "ad8d45945d6a4f088a61fd605c38cdf2f40171624bca2a7c3b2d4e95b068eb3d",
+      "localBytecodeHash": "bca15bc1a7aa87c603c9b185aab38e0d72b8adc6347426bb66954cef39e88a74",
+      "deployedBytecodeHash": "bca15bc1a7aa87c603c9b185aab38e0d72b8adc6347426bb66954cef39e88a74",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_uint8": {
+          "id": "t_uint8",
+          "kind": "elementary",
+          "label": "uint8"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 9641,
+          "type": "t_string",
+          "src": "209:20:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 9643,
+          "type": "t_string",
+          "src": "235:22:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 9645,
+          "type": "t_uint8",
+          "src": "263:23:118"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 9697,
+          "type": "t_array:50<t_uint256>",
+          "src": "1645:29:118"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 9129,
+          "type": "t_mapping<t_uint256>",
+          "src": "1357:46:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 9135,
+          "type": "t_mapping<t_uint256>",
+          "src": "1410:69:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 9137,
+          "type": "t_uint256",
+          "src": "1486:28:115"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 9516,
+          "type": "t_array:50<t_uint256>",
+          "src": "7875:29:115"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 219,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 319,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:2"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 9746,
+          "type": "t_array:50<t_uint256>",
+          "src": "816:29:119"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 339,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 439,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4481,
+          "type": "t_bool",
+          "src": "855:20:37"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4564,
+          "type": "t_array:50<t_uint256>",
+          "src": "2105:29:37"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 9869,
+          "type": "t_array:50<t_uint256>",
+          "src": "1178:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0xf43fe8b882b9821b3d648fb9f4d99d2fd736368c",
+      "constructorCode": "608060405234801561001057600080fd5b50614299806100206000396000f3fe",
+      "bodyBytecodeHash": "9113153cb4b2b62f720cb12960ba3b4a7b9a5f3329e34a4a3ece0212d130ae53",
+      "localBytecodeHash": "5dca693db1fee9a4ce973e49d6665a8770b823c36ba2c7e64f37d81046672074",
+      "deployedBytecodeHash": "5dca693db1fee9a4ce973e49d6665a8770b823c36ba2c7e64f37d81046672074",
+      "types": {
+        "t_bool": {
+          "id": "t_bool",
+          "kind": "elementary",
+          "label": "bool"
+        },
+        "t_uint256": {
+          "id": "t_uint256",
+          "kind": "elementary",
+          "label": "uint256"
+        },
+        "t_array:50<t_uint256>": {
+          "id": "t_array:50<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "50",
+          "kind": "array",
+          "label": "uint256[50]"
+        },
+        "t_mapping<t_bool>": {
+          "id": "t_mapping<t_bool>",
+          "valueType": "t_bool",
+          "label": "mapping(key => bool)",
+          "kind": "mapping"
+        },
+        "t_address": {
+          "id": "t_address",
+          "kind": "elementary",
+          "label": "address"
+        },
+        "t_mapping<t_address>": {
+          "id": "t_mapping<t_address>",
+          "valueType": "t_address",
+          "label": "mapping(key => address)",
+          "kind": "mapping"
+        },
+        "t_struct<Counters.Counter>": {
+          "id": "t_struct<Counters.Counter>",
+          "kind": "struct",
+          "label": "Counters.Counter",
+          "members": [
+            {
+              "label": "_value",
+              "astId": 2533,
+              "type": "t_uint256",
+              "src": "1022:14:22"
+            }
+          ]
+        },
+        "t_mapping<t_struct<Counters.Counter>>": {
+          "id": "t_mapping<t_struct<Counters.Counter>>",
+          "valueType": "t_struct<Counters.Counter>",
+          "label": "mapping(key => Counters.Counter)",
+          "kind": "mapping"
+        },
+        "t_array:dyn<t_uint256>": {
+          "id": "t_array:dyn<t_uint256>",
+          "valueType": "t_uint256",
+          "length": "dyn",
+          "kind": "array",
+          "label": "uint256[]"
+        },
+        "t_mapping<t_array:dyn<t_uint256>>": {
+          "id": "t_mapping<t_array:dyn<t_uint256>>",
+          "valueType": "t_array:dyn<t_uint256>",
+          "label": "mapping(key => uint256[])",
+          "kind": "mapping"
+        },
+        "t_mapping<t_uint256>": {
+          "id": "t_mapping<t_uint256>",
+          "valueType": "t_uint256",
+          "label": "mapping(key => uint256)",
+          "kind": "mapping"
+        },
+        "t_string": {
+          "id": "t_string",
+          "kind": "elementary",
+          "label": "string"
+        },
+        "t_mapping<t_string>": {
+          "id": "t_mapping<t_string>",
+          "valueType": "t_string",
+          "label": "mapping(key => string)",
+          "kind": "mapping"
+        },
+        "t_struct<Roles.Role>": {
+          "id": "t_struct<Roles.Role>",
+          "kind": "struct",
+          "label": "Roles.Role",
+          "members": [
+            {
+              "label": "bearer",
+              "astId": 5,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:0"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13503,
+          "type": "t_bool",
+          "src": "757:24:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13505,
+          "type": "t_bool",
+          "src": "876:25:147"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13554,
+          "type": "t_array:50<t_uint256>",
+          "src": "1891:29:147"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 4117,
+          "type": "t_mapping<t_bool>",
+          "src": "550:52:31"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 4162,
+          "type": "t_array:50<t_uint256>",
+          "src": "1714:29:31"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 10508,
+          "type": "t_mapping<t_address>",
+          "src": "829:48:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 10512,
+          "type": "t_mapping<t_address>",
+          "src": "933:52:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 10516,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1043:63:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 10522,
+          "type": "t_mapping<t_bool>",
+          "src": "1161:73:125"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 11065,
+          "type": "t_array:50<t_uint256>",
+          "src": "12696:29:125"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 11117,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "445:50:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 11121,
+          "type": "t_mapping<t_uint256>",
+          "src": "565:53:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 11124,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "679:28:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 11128,
+          "type": "t_mapping<t_uint256>",
+          "src": "778:51:127"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 11459,
+          "type": "t_array:50<t_uint256>",
+          "src": "8994:29:127"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 11526,
+          "type": "t_string",
+          "src": "266:20:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 11528,
+          "type": "t_string",
+          "src": "313:22:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 11532,
+          "type": "t_mapping<t_string>",
+          "src": "381:45:130"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 11663,
+          "type": "t_array:50<t_uint256>",
+          "src": "3029:29:130"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 219,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:2"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 319,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:2"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 11733,
+          "type": "t_array:50<t_uint256>",
+          "src": "1042:29:131"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 339,
+          "type": "t_struct<Roles.Role>",
+          "src": "271:27:3"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 439,
+          "type": "t_array:50<t_uint256>",
+          "src": "1133:29:3"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 4481,
+          "type": "t_bool",
+          "src": "855:20:37"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 4564,
+          "type": "t_array:50<t_uint256>",
+          "src": "2105:29:37"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 11878,
+          "type": "t_array:50<t_uint256>",
+          "src": "850:29:133"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x27a09abca2c4d9f914dbc7bea164b0e6b74ce7a9"
+  },
+  "package": {
+    "address": "0x2a9e7b63514438906a83a1e320dbbd814d417002"
+  },
+  "provider": {
+    "address": "0xb818f726ea886a73dc4105252f0e7c10b6309cae"
+  },
+  "version": "2.2.0"
+}

CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 2.2.1 (2019-07-22)
+
+### Changes:
+* Renamed package to `@openzeppelin/contracts-ethereum-package`. ([#54](https://github.com/OpenZeppelin/openzeppelin-contracts-ethereum-package/pull/54))
+
 ## 2.2.0 (2019-03-14)
 
 ### New features:

README.md

@@ -1,42 +1,98 @@
 # <img src="logo.png" alt="OpenZeppelin" width="400px">
 
-[![NPM Package](https://img.shields.io/npm/v/openzeppelin-solidity.svg?style=flat-square)](https://www.npmjs.org/package/openzeppelin-solidity)
-[![Build Status](https://travis-ci.com/OpenZeppelin/openzeppelin-solidity.svg?branch=master)](https://travis-ci.com/OpenZeppelin/openzeppelin-solidity)
-[![Coverage Status](https://coveralls.io/repos/github/OpenZeppelin/openzeppelin-solidity/badge.svg?branch=master)](https://coveralls.io/github/OpenZeppelin/openzeppelin-solidity?branch=master)
+# OpenZeppelin Contracts Ethereum Package
 
-**OpenZeppelin is a library for secure smart contract development.** It provides implementations of standards like ERC20 and ERC721 which you can deploy as-is or extend to suit your needs, as well as Solidity components to build custom contracts and more complex decentralized systems.
+[![NPM Package](https://img.shields.io/npm/v/openzeppelin-contracts-ethereum-package.svg?style=flat-square)](https://www.npmjs.org/package/@openzeppelin/contracts-ethereum-package)
+[![Build Status](https://img.shields.io/travis/OpenZeppelin/openzeppelin-contracts-ethereum-package.svg?branch=master&style=flat-square)](https://travis-ci.org/OpenZeppelin/openzeppelin-contracts-ethereum-package)
+
+**OpenZeppelin Contracts is a library for secure smart contract development.** It provides implementations of standards like ERC20 and ERC721 which you can deploy as-is or extend to suit your needs, as well as Solidity components to build custom contracts and more complex decentralized systems.
+
+This fork of OpenZeppelin is set up as a **reusable Ethereum Package**. It is deployed to the kovan, rinkeby, and ropsten test networks, as well as to the main Ethereum network. You can reuse any of the pre-deployed on-chain contracts by simply linking to them using the [OpenZeppelin SDK](https://github.com/openzeppelin/openzeppelin-sdk), or reuse their Solidity source code as with the [vanilla version of OpenZeppelin Contracts](https://github.com/OpenZeppelin/openzeppelin-contracts).
+
+## Differences with openzeppelin-contracts
+
+This package contains the same contracts as the vanilla [openzeppelin-contracts](https://github.com/openZeppelin/openzeppelin-contracts). The main difference is that _all contracts in this package are potentially upgradeable_: you will notice that no contracts have constructors defined, but use [initializer functions](https://docs.zeppelinos.org/docs/writing_contracts.html#initializers) instead. Also, this package is set up as an Ethereum package, and provides a small set of pre-deployed logic contracts that can be used directly via the OpenZeppelin SDK, without needing to deploy them again.
+
+All in all, **you should use this package instead of openzeppelin-solidity if you are managing your project via the OpenZeppelin CLI**.
 
 ## Install
 
 ```
-npm install openzeppelin-solidity
+npm install @openzeppelin/contracts-ethereum-package
 ```
 
-## Usage
+## Deployed logic contracts
 
-To write your custom contracts, import ours and extend them through inheritance.
+- [StandaloneERC20](contracts/token/ERC20/StandaloneERC20.sol): ERC20 token implementation, optionally mintable and pausable.
+- [StandaloneERC721](contracts/token/ERC721/StandaloneERC721.sol): ERC721 non-fungible token implementation with metadata and enumerable extensions, optionally mintable and pausable.
+- [TokenVesting](contracts/drafts/TokenVesting.sol): tToken holder contract that can release its token balance gradually like a typical vesting scheme, with a cliff and vesting period, optionally revocable.
+- [PaymentSplitter](contracts/payment/PaymentSplitter.sol): Splits payments among a group of addresses proportionately to some number of shares they own.
+
+## Using via the OpenZeppelin CLI
+
+You can easily create upgradeable instances of any of the logic contracts listed above using the OpenZeppelin CLI. This will rely on the pre-deployed instances in mainnet, kovan, ropsten, or rinkeby, greatly reducing your gas deployment costs. To do this, just [create a new OpenZeppelin SDK project](https://docs.zeppelinos.org/docs/deploying.html) and [link to this package](https://docs.zeppelinos.org/docs/linking.html).
+
+```bash
+$ npm install -g @openzeppelin/cli
+$ openzeppelin init
+$ openzeppelin link @openzeppelin/contracts-ethereum-package
+> Installing...
+$ openzeppelin create @openzeppelin/contracts-ethereum-package/StandaloneERC20
+> Creating...
+```
+
+To create an instance of a contract, use the `openzeppelin create` command. As an example, you can run the following to create an upgradeable ERC20 named MyToken, with symbol TKN and 8 decimals, and an initial supply of 100 tokens assigned to the address HOLDER, with a MINTER and a PAUSER. Remember to replace $HOLDER, $MINTER, and $PAUSER with actual addresses when you run this command; you can specify more than one (or none at all) minters and pausers.
+
+```
+$ openzeppelin create
+? Pick a contract to instantiate: @openzeppelin/contracts-ethereum-package/StandaloneERC20
+? Pick a network: development
+✓ Deploying @openzeppelin/contracts-ethereum-package dependency to network
+? Do you want to call a function on the instance after creating it?: Yes
+? Select which function: * initialize(name: string, symbol: string, decimals: uint8, initialSupply: uint256, initialHolder: address, minters: address[], pausers: address[])
+? name (string): MyToken
+? symbol (string): MYT
+? decimals (uint8): 18
+? initialSupply (uint256): 100e18
+? initialHolder (address): 0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1
+? minters (address[]): 
+? pausers (address[]): 
+✓ Setting everything up to create contract instances
+✓ Instance created at 0x2612Af3A521c2df9EAF28422Ca335b04AdF3ac66
+```
+
+OpenZeppelin will create an upgradeable ERC20 instance and keep track of its address in the `.openzeppelin/rinkeby.json` file. Should you update your version of the openzeppelin contracts ethereum package later down the road, you can simply run `openzeppelin update` to upgrade all your ERC20 instances to the latest version.
+
+You can also deploy a ERC721 token by choosing the `StandaloneERC721` contract when running `openzeppelin create`. Refer to the `initialize` function of each of the predeployed logic contracts to see which parameters are required for initialization.
+
+## Extending contracts
+
+If you prefer to write your custom contracts, import the ones from this package and extend them through inheritance. Note that **you must use this package and not `@openzeppelin/contracts` if you are [writing upgradeable contracts](https://docs.zeppelinos.org/docs/writing_contracts.html)**.
 
 ```solidity
 pragma solidity ^0.5.0;
 
-import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol';
-import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Mintable.sol';
+import '@openzeppelin/upgrades/contracts/Initializable.sol';
+import '@openzeppelin/contracts-ethereum-package/contracts/token/ERC721/ERC721Full.sol';
+import '@openzeppelin/contracts-ethereum-package/contracts/token/ERC721/ERC721Mintable.sol';
 
-contract MyNFT is ERC721Full, ERC721Mintable {
-  constructor() ERC721Full("MyNFT", "MNFT") public {
+contract MyNFT is Initializable, ERC721Full, ERC721Mintable {
+  function initialize() public initializer {
+    ERC721.initialize();
+    ERC721Enumerable.initialize();
+    ERC721Metadata.initialize("MyNFT", "MNFT");
+    ERC721Mintable.initialize(msg.sender);
   }
 }
 ```
 
-> You need an ethereum development framework for the above import statements to work! Check out these guides for [Truffle] or [Embark].
-
-On our site you will find a few [guides] to learn about the different parts of OpenZeppelin, as well as [documentation for the API][API docs]. Keep in mind that the API docs are work in progress, and don’t hesitate to ask questions in [our Slack][Slack].
+On our site you will find a few [guides] to learn about the different parts of OpenZeppelin, as well as [documentation for the API][API docs]. Keep in mind that the API docs are work in progress, and don’t hesitate to ask questions in [our forum][forum].
 
 ## Security
 
-OpenZeppelin the project is maintained by [Zeppelin] the company, and developed following our high standards for code quality and security. OpenZeppelin is meant to provide tested and community-audited code, but please use common sense when doing anything that deals with real money! We take no responsibility for your implementation decisions and any security problems you might experience.
+OpenZeppelin Contracts is maintained by [OpenZeppelin](https://openzeppelin.com) the company, and developed following our high standards for code quality and security. OpenZeppelin Contracts is meant to provide tested and community-audited code, but please use common sense when doing anything that deals with real money! We take no responsibility for your implementation decisions and any security problems you might experience.
 
-The core development principles and strategies that OpenZeppelin is based on include: security in depth, simple and modular code, clarity-driven naming conventions, comprehensive unit testing, pre-and-post-condition sanity checks, code consistency, and regular audits.
+The core development principles and strategies that OpenZeppelin Contracts is based on include: security in depth, simple and modular code, clarity-driven naming conventions, comprehensive unit testing, pre-and-post-condition sanity checks, code consistency, and regular audits.
 
 The latest audit was done on October 2018 on version 2.0.0.
 
@@ -50,11 +106,7 @@ OpenZeppelin exists thanks to its contributors. There are many ways you can part
 
 OpenZeppelin is released under the [MIT License](LICENSE).
 
-
-[API docs]: https://openzeppelin.org/api/docs/token_ERC721_ERC721BasicToken.html
-[guides]: https://openzeppelin.org/api/docs/get-started.html
-[Slack]: https://slack.openzeppelin.org
-[Zeppelin]: https://zeppelin.solutions
+[API docs]: https://docs.openzeppelin.org/v2.3.0/api/token/erc20
+[guides]: https://docs.openzeppelin.org/v2.3.0/get-started
+[forum]: https://forum.zeppelin.solutions
 [contribution guide]: CONTRIBUTING.md
-[Truffle]: https://truffleframework.com/docs/truffle/quickstart
-[Embark]: https://embark.status.im/docs/quick_start.html

contracts/access/roles/CapperRole.sol

@@ -1,8 +1,10 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../Roles.sol";
 
-contract CapperRole {
+
+contract CapperRole is Initializable {
     using Roles for Roles.Role;
 
     event CapperAdded(address indexed account);
@@ -10,8 +12,10 @@ contract CapperRole {
 
     Roles.Role private _cappers;
 
-    constructor () internal {
-        _addCapper(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isCapper(sender)) {
+            _addCapper(sender);
+        }
     }
 
     modifier onlyCapper() {
@@ -40,4 +44,6 @@ contract CapperRole {
         _cappers.remove(account);
         emit CapperRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/MinterRole.sol

@@ -1,8 +1,10 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../Roles.sol";
 
-contract MinterRole {
+
+contract MinterRole is Initializable {
     using Roles for Roles.Role;
 
     event MinterAdded(address indexed account);
@@ -10,8 +12,10 @@ contract MinterRole {
 
     Roles.Role private _minters;
 
-    constructor () internal {
-        _addMinter(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isMinter(sender)) {
+            _addMinter(sender);
+        }
     }
 
     modifier onlyMinter() {
@@ -40,4 +44,6 @@ contract MinterRole {
         _minters.remove(account);
         emit MinterRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/PauserRole.sol

@@ -1,8 +1,10 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../Roles.sol";
 
-contract PauserRole {
+
+contract PauserRole is Initializable {
     using Roles for Roles.Role;
 
     event PauserAdded(address indexed account);
@@ -10,8 +12,10 @@ contract PauserRole {
 
     Roles.Role private _pausers;
 
-    constructor () internal {
-        _addPauser(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isPauser(sender)) {
+            _addPauser(sender);
+        }
     }
 
     modifier onlyPauser() {
@@ -40,4 +44,6 @@ contract PauserRole {
         _pausers.remove(account);
         emit PauserRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/SignerRole.sol

@@ -1,8 +1,10 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../Roles.sol";
 
-contract SignerRole {
+
+contract SignerRole is Initializable {
     using Roles for Roles.Role;
 
     event SignerAdded(address indexed account);
@@ -10,8 +12,10 @@ contract SignerRole {
 
     Roles.Role private _signers;
 
-    constructor () internal {
-        _addSigner(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isSigner(sender)) {
+            _addSigner(sender);
+        }
     }
 
     modifier onlySigner() {
@@ -40,4 +44,6 @@ contract SignerRole {
         _signers.remove(account);
         emit SignerRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/WhitelistAdminRole.sol

@@ -1,12 +1,14 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "../Roles.sol";
 
 /**
  * @title WhitelistAdminRole
  * @dev WhitelistAdmins are responsible for assigning and removing Whitelisted accounts.
  */
-contract WhitelistAdminRole {
+contract WhitelistAdminRole is Initializable {
     using Roles for Roles.Role;
 
     event WhitelistAdminAdded(address indexed account);
@@ -14,8 +16,10 @@ contract WhitelistAdminRole {
 
     Roles.Role private _whitelistAdmins;
 
-    constructor () internal {
-        _addWhitelistAdmin(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isWhitelistAdmin(sender)) {
+            _addWhitelistAdmin(sender);
+        }
     }
 
     modifier onlyWhitelistAdmin() {
@@ -44,4 +48,6 @@ contract WhitelistAdminRole {
         _whitelistAdmins.remove(account);
         emit WhitelistAdminRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/WhitelistedRole.sol

@@ -1,5 +1,7 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "../Roles.sol";
 import "./WhitelistAdminRole.sol";
 
@@ -9,7 +11,7 @@ import "./WhitelistAdminRole.sol";
  * crowdsale). This role is special in that the only accounts that can add it are WhitelistAdmins (who can also remove
  * it), and not Whitelisteds themselves.
  */
-contract WhitelistedRole is WhitelistAdminRole {
+contract WhitelistedRole is Initializable, WhitelistAdminRole {
     using Roles for Roles.Role;
 
     event WhitelistedAdded(address indexed account);
@@ -22,6 +24,10 @@ contract WhitelistedRole is WhitelistAdminRole {
         _;
     }
 
+    function initialize(address sender) public initializer {
+        WhitelistAdminRole.initialize(sender);
+    }
+
     function isWhitelisted(address account) public view returns (bool) {
         return _whitelisteds.has(account);
     }
@@ -47,4 +53,6 @@ contract WhitelistedRole is WhitelistAdminRole {
         _whitelisteds.remove(account);
         emit WhitelistedRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/Crowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../token/ERC20/IERC20.sol";
 import "../math/SafeMath.sol";
 import "../token/ERC20/SafeERC20.sol";
@@ -17,7 +18,7 @@ import "../utils/ReentrancyGuard.sol";
  * the methods to add functionality. Consider using 'super' where appropriate to concatenate
  * behavior.
  */
-contract Crowdsale is ReentrancyGuard {
+contract Crowdsale is Initializable, ReentrancyGuard {
     using SafeMath for uint256;
     using SafeERC20 for IERC20;
 
@@ -53,7 +54,7 @@ contract Crowdsale is ReentrancyGuard {
      * @param wallet Address where collected funds will be forwarded to
      * @param token Address of the token being sold
      */
-    constructor (uint256 rate, address payable wallet, IERC20 token) public {
+    function initialize(uint256 rate, address payable wallet, IERC20 token) public initializer {
         require(rate > 0);
         require(wallet != address(0));
         require(address(token) != address(0));
@@ -126,6 +127,10 @@ contract Crowdsale is ReentrancyGuard {
         _postValidatePurchase(beneficiary, weiAmount);
     }
 
+    function _hasBeenInitialized() internal view returns (bool) {
+        return ((_rate > 0) && (_wallet != address(0)) && (address(_token) != address(0)));
+    }
+
     /**
      * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
      * Use `super` in contracts that inherit from Crowdsale to extend their validations.
@@ -195,4 +200,6 @@ contract Crowdsale is ReentrancyGuard {
     function _forwardFunds() internal {
         _wallet.transfer(msg.value);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/distribution/FinalizableCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "../validation/TimedCrowdsale.sol";
 
@@ -8,17 +9,13 @@ import "../validation/TimedCrowdsale.sol";
  * @dev Extension of TimedCrowdsale with a one-off finalization action, where one
  * can do extra work after finishing.
  */
-contract FinalizableCrowdsale is TimedCrowdsale {
+contract FinalizableCrowdsale is Initializable, TimedCrowdsale {
     using SafeMath for uint256;
 
     bool private _finalized;
 
     event CrowdsaleFinalized();
 
-    constructor () internal {
-        _finalized = false;
-    }
-
     /**
      * @return true if the crowdsale is finalized, false otherwise.
      */
@@ -48,4 +45,6 @@ contract FinalizableCrowdsale is TimedCrowdsale {
     function _finalization() internal {
         // solhint-disable-previous-line no-empty-blocks
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../validation/TimedCrowdsale.sol";
 import "../../math/SafeMath.sol";
 
@@ -7,7 +8,7 @@ import "../../math/SafeMath.sol";
  * @title PostDeliveryCrowdsale
  * @dev Crowdsale that locks tokens from withdrawal until it ends.
  */
-contract PostDeliveryCrowdsale is TimedCrowdsale {
+contract PostDeliveryCrowdsale is Initializable, TimedCrowdsale {
     using SafeMath for uint256;
 
     mapping(address => uint256) private _balances;
@@ -40,4 +41,5 @@ contract PostDeliveryCrowdsale is TimedCrowdsale {
         _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
     }
 
+    uint256[50] private ______gap;
 }

contracts/crowdsale/distribution/RefundableCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "./FinalizableCrowdsale.sol";
 import "../../payment/escrow/RefundEscrow.sol";
@@ -14,7 +15,7 @@ import "../../payment/escrow/RefundEscrow.sol";
  * the goal is unlikely to be met, they sell their tokens (possibly at a discount). The attacker will be refunded when
  * the crowdsale is finalized, and the users that purchased from them will be left with worthless tokens.
  */
-contract RefundableCrowdsale is FinalizableCrowdsale {
+contract RefundableCrowdsale is Initializable, FinalizableCrowdsale {
     using SafeMath for uint256;
 
     // minimum amount of funds to be raised in weis
@@ -27,9 +28,16 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
      * @dev Constructor, creates RefundEscrow.
      * @param goal Funding goal
      */
-    constructor (uint256 goal) public {
+    function initialize(uint256 goal) public initializer {
+        // FinalizableCrowdsale depends on TimedCrowdsale
+        assert(TimedCrowdsale._hasBeenInitialized());
+
         require(goal > 0);
-        _escrow = new RefundEscrow(wallet());
+        // conditional added to make initializer idempotent in case of diamond inheritance
+        if (address(_escrow) == address(0)) {
+            _escrow = new RefundEscrow();
+            _escrow.initialize(wallet(), address(this));
+        }
         _goal = goal;
     }
 
@@ -79,4 +87,6 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
     function _forwardFunds() internal {
         _escrow.deposit.value(msg.value)(msg.sender);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/distribution/RefundablePostDeliveryCrowdsale.sol

@@ -1,20 +1,23 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "./RefundableCrowdsale.sol";
 import "./PostDeliveryCrowdsale.sol";
 
-
 /**
  * @title RefundablePostDeliveryCrowdsale
  * @dev Extension of RefundableCrowdsale contract that only delivers the tokens
  * once the crowdsale has closed and the goal met, preventing refunds to be issued
  * to token holders.
  */
-contract RefundablePostDeliveryCrowdsale is RefundableCrowdsale, PostDeliveryCrowdsale {
+contract RefundablePostDeliveryCrowdsale is Initializable, RefundableCrowdsale, PostDeliveryCrowdsale {
     function withdrawTokens(address beneficiary) public {
         require(finalized());
         require(goalReached());
 
         super.withdrawTokens(beneficiary);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/emission/AllowanceCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../Crowdsale.sol";
 import "../../token/ERC20/IERC20.sol";
 import "../../token/ERC20/SafeERC20.sol";
@@ -10,7 +11,7 @@ import "../../math/Math.sol";
  * @title AllowanceCrowdsale
  * @dev Extension of Crowdsale where tokens are held by a wallet, which approves an allowance to the crowdsale.
  */
-contract AllowanceCrowdsale is Crowdsale {
+contract AllowanceCrowdsale is Initializable, Crowdsale {
     using SafeMath for uint256;
     using SafeERC20 for IERC20;
 
@@ -20,7 +21,9 @@ contract AllowanceCrowdsale is Crowdsale {
      * @dev Constructor, takes token wallet address.
      * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale
      */
-    constructor (address tokenWallet) public {
+    function initialize(address tokenWallet) public initializer {
+        assert(Crowdsale._hasBeenInitialized());
+
         require(tokenWallet != address(0));
         _tokenWallet = tokenWallet;
     }
@@ -48,4 +51,6 @@ contract AllowanceCrowdsale is Crowdsale {
     function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
         token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/emission/MintedCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../Crowdsale.sol";
 import "../../token/ERC20/ERC20Mintable.sol";
 
@@ -8,7 +9,7 @@ import "../../token/ERC20/ERC20Mintable.sol";
  * @dev Extension of Crowdsale contract whose tokens are minted in each purchase.
  * Token ownership should be transferred to MintedCrowdsale for minting.
  */
-contract MintedCrowdsale is Crowdsale {
+contract MintedCrowdsale is Initializable, Crowdsale {
     /**
      * @dev Overrides delivery by minting tokens upon purchase.
      * @param beneficiary Token purchaser
@@ -18,4 +19,6 @@ contract MintedCrowdsale is Crowdsale {
         // Potentially dangerous assumption about the type of the token.
         require(ERC20Mintable(address(token())).mint(beneficiary, tokenAmount));
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/price/IncreasingPriceCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../validation/TimedCrowdsale.sol";
 import "../../math/SafeMath.sol";
 
@@ -9,7 +10,7 @@ import "../../math/SafeMath.sol";
  * Note that what should be provided to the constructor is the initial and final _rates_, that is,
  * the amount of tokens per wei contributed. Thus, the initial rate must be greater than the final rate.
  */
-contract IncreasingPriceCrowdsale is TimedCrowdsale {
+contract IncreasingPriceCrowdsale is Initializable, TimedCrowdsale {
     using SafeMath for uint256;
 
     uint256 private _initialRate;
@@ -20,7 +21,9 @@ contract IncreasingPriceCrowdsale is TimedCrowdsale {
      * @param initialRate Number of tokens a buyer gets per wei at the start of the crowdsale
      * @param finalRate Number of tokens a buyer gets per wei at the end of the crowdsale
      */
-    constructor (uint256 initialRate, uint256 finalRate) public {
+    function initialize(uint256 initialRate, uint256 finalRate) public initializer {
+        assert(TimedCrowdsale._hasBeenInitialized());
+
         require(finalRate > 0);
         require(initialRate > finalRate);
         _initialRate = initialRate;
@@ -75,4 +78,6 @@ contract IncreasingPriceCrowdsale is TimedCrowdsale {
         uint256 currentRate = getCurrentRate();
         return currentRate.mul(weiAmount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/validation/CappedCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";
 
@@ -7,7 +8,7 @@ import "../Crowdsale.sol";
  * @title CappedCrowdsale
  * @dev Crowdsale with a limit for total contributions.
  */
-contract CappedCrowdsale is Crowdsale {
+contract CappedCrowdsale is Initializable, Crowdsale {
     using SafeMath for uint256;
 
     uint256 private _cap;
@@ -16,7 +17,9 @@ contract CappedCrowdsale is Crowdsale {
      * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
      * @param cap Max amount of wei to be contributed
      */
-    constructor (uint256 cap) public {
+    function initialize(uint256 cap) public initializer {
+        assert(Crowdsale._hasBeenInitialized());
+
         require(cap > 0);
         _cap = cap;
     }
@@ -45,4 +48,6 @@ contract CappedCrowdsale is Crowdsale {
         super._preValidatePurchase(beneficiary, weiAmount);
         require(weiRaised().add(weiAmount) <= _cap);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";
 import "../../access/roles/CapperRole.sol";
@@ -8,12 +9,18 @@ import "../../access/roles/CapperRole.sol";
  * @title IndividuallyCappedCrowdsale
  * @dev Crowdsale with per-beneficiary caps.
  */
-contract IndividuallyCappedCrowdsale is Crowdsale, CapperRole {
+contract IndividuallyCappedCrowdsale is Initializable, Crowdsale, CapperRole {
     using SafeMath for uint256;
 
     mapping(address => uint256) private _contributions;
     mapping(address => uint256) private _caps;
 
+    function initialize(address sender) public initializer {
+        assert(Crowdsale._hasBeenInitialized());
+
+        CapperRole.initialize(sender);
+    }
+
     /**
      * @dev Sets a specific beneficiary's maximum contribution.
      * @param beneficiary Address to be capped
@@ -60,4 +67,6 @@ contract IndividuallyCappedCrowdsale is Crowdsale, CapperRole {
         super._updatePurchasingState(beneficiary, weiAmount);
         _contributions[beneficiary] = _contributions[beneficiary].add(weiAmount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/validation/PausableCrowdsale.sol

@@ -1,5 +1,7 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "../Crowdsale.sol";
 import "../../lifecycle/Pausable.sol";
 
@@ -7,7 +9,13 @@ import "../../lifecycle/Pausable.sol";
  * @title PausableCrowdsale
  * @dev Extension of Crowdsale contract where purchases can be paused and unpaused by the pauser role.
  */
-contract PausableCrowdsale is Crowdsale, Pausable {
+contract PausableCrowdsale is Initializable, Crowdsale, Pausable {
+    function initialize(address sender) public initializer {
+        assert(Crowdsale._hasBeenInitialized());
+
+        Pausable.initialize(sender);
+    }
+
     /**
      * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
      * Use super to concatenate validations.
@@ -18,4 +26,6 @@ contract PausableCrowdsale is Crowdsale, Pausable {
     function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view whenNotPaused {
         return super._preValidatePurchase(_beneficiary, _weiAmount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/validation/TimedCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";
 
@@ -7,7 +8,7 @@ import "../Crowdsale.sol";
  * @title TimedCrowdsale
  * @dev Crowdsale accepting contributions only within a time frame.
  */
-contract TimedCrowdsale is Crowdsale {
+contract TimedCrowdsale is Initializable, Crowdsale {
     using SafeMath for uint256;
 
     uint256 private _openingTime;
@@ -33,7 +34,9 @@ contract TimedCrowdsale is Crowdsale {
      * @param openingTime Crowdsale opening time
      * @param closingTime Crowdsale closing time
      */
-    constructor (uint256 openingTime, uint256 closingTime) public {
+    function initialize(uint256 openingTime, uint256 closingTime) public initializer {
+        assert(Crowdsale._hasBeenInitialized());
+
         // solhint-disable-next-line not-rely-on-time
         require(openingTime >= block.timestamp);
         require(closingTime > openingTime);
@@ -73,6 +76,10 @@ contract TimedCrowdsale is Crowdsale {
         return block.timestamp > _closingTime;
     }
 
+    function _hasBeenInitialized() internal view returns (bool) {
+        return ((_openingTime > 0) && (_closingTime > 0));
+    }
+
     /**
      * @dev Extend parent behavior requiring to be within contributing period
      * @param beneficiary Token purchaser
@@ -93,4 +100,6 @@ contract TimedCrowdsale is Crowdsale {
         emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
         _closingTime = newClosingTime;
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/validation/WhitelistCrowdsale.sol

@@ -7,7 +7,13 @@ import "../../access/roles/WhitelistedRole.sol";
  * @title WhitelistCrowdsale
  * @dev Crowdsale in which only whitelisted users can contribute.
  */
-contract WhitelistCrowdsale is WhitelistedRole, Crowdsale {
+contract WhitelistCrowdsale is Initializable, WhitelistedRole, Crowdsale {
+    function initialize(address sender) public initializer {
+        WhitelistedRole.initialize(sender);
+
+        assert(Crowdsale._hasBeenInitialized());
+    }
+
     /**
      * @dev Extend parent behavior requiring beneficiary to be whitelisted. Note that no
      * restriction is imposed on the account sending the transaction.
@@ -18,4 +24,6 @@ contract WhitelistCrowdsale is WhitelistedRole, Crowdsale {
         require(isWhitelisted(_beneficiary));
         super._preValidatePurchase(_beneficiary, _weiAmount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC1046/ERC20Metadata.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../token/ERC20/IERC20.sol";
 
 /**
@@ -7,10 +8,10 @@ import "../../token/ERC20/IERC20.sol";
  * @dev See https://eips.ethereum.org/EIPS/eip-1046
  * @dev tokenURI must respond with a URI that implements https://eips.ethereum.org/EIPS/eip-1047
  */
-contract ERC20Metadata {
+contract ERC20Metadata is Initializable {
     string private _tokenURI;
 
-    constructor (string memory tokenURI_) public {
+    function initialize(string memory tokenURI_) public {
         _setTokenURI(tokenURI_);
     }
 
@@ -21,4 +22,6 @@ contract ERC20Metadata {
     function _setTokenURI(string memory tokenURI_) internal {
         _tokenURI = tokenURI_;
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC20Migrator.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../token/ERC20/IERC20.sol";
 import "../token/ERC20/ERC20Mintable.sol";
 import "../token/ERC20/SafeERC20.sol";
@@ -21,9 +22,9 @@ import "../math/Math.sol";
  * is migrated, and remain there forever.
  * Although this contract can be used in many different scenarios, the main
  * motivation was to provide a way to migrate ERC20 tokens into an upgradeable
- * version of it using ZeppelinOS. To read more about how this can be done
+ * version of it using the OpenZeppelin SDK. To read more about how this can be done
  * using this implementation, please follow the official documentation site of
- * ZeppelinOS: https://docs.zeppelinos.org/docs/erc20_onboarding.html
+ * the OpenZeppelinSDK: https://docs.zeppelinos.org/docs/erc20_onboarding.html
  * Example of usage:
  * ```
  * const migrator = await ERC20Migrator.new(legacyToken.address);
@@ -31,7 +32,7 @@ import "../math/Math.sol";
  * await migrator.beginMigration(newToken.address);
  * ```
  */
-contract ERC20Migrator {
+contract ERC20Migrator is Initializable {
     using SafeERC20 for IERC20;
 
     /// Address of the old token contract
@@ -43,7 +44,7 @@ contract ERC20Migrator {
     /**
      * @param legacyToken address of the old token contract
      */
-    constructor (IERC20 legacyToken) public {
+    function initialize(IERC20 legacyToken) public initializer {
         require(address(legacyToken) != address(0));
         _legacyToken = legacyToken;
     }
@@ -98,4 +99,6 @@ contract ERC20Migrator {
         uint256 amount = Math.min(balance, allowance);
         migrate(account, amount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC20Snapshot.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../math/SafeMath.sol";
 import "../utils/Arrays.sol";
 import "../drafts/Counters.sol";
@@ -18,7 +19,7 @@ import "../token/ERC20/ERC20.sol";
  * account address.
  * @author Validity Labs AG <info@validitylabs.org>
  */
-contract ERC20Snapshot is ERC20 {
+contract ERC20Snapshot is Initializable, ERC20 {
     using SafeMath for uint256;
     using Arrays for uint256[];
     using Counters for Counters.Counter;
@@ -136,4 +137,6 @@ contract ERC20Snapshot is ERC20 {
             return ids[ids.length - 1];
         }
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/SignatureBouncer.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../access/roles/SignerRole.sol";
 import "../cryptography/ECDSA.sol";
 
@@ -34,7 +35,7 @@ import "../cryptography/ECDSA.sol";
  * the data in the signature much more complex.
  * See https://ethereum.stackexchange.com/a/50616 for more details.
  */
-contract SignatureBouncer is SignerRole {
+contract SignatureBouncer is Initializable, SignerRole {
     using ECDSA for bytes32;
 
     // Function selectors are 4 bytes long, as documented in
@@ -43,8 +44,8 @@ contract SignatureBouncer is SignerRole {
     // Signature size is 65 bytes (tightly packed v + r + s), but gets padded to 96 bytes
     uint256 private constant _SIGNATURE_SIZE = 96;
 
-    constructor () internal {
-        // solhint-disable-previous-line no-empty-blocks
+    function initialize(address sender) public initializer {
+        SignerRole.initialize(sender);
     }
 
     /**
@@ -117,4 +118,6 @@ contract SignatureBouncer is SignerRole {
 
         return signer != address(0) && isSigner(signer);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/TokenVesting.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../token/ERC20/SafeERC20.sol";
 import "../ownership/Ownable.sol";
 import "../math/SafeMath.sol";
@@ -10,7 +11,7 @@ import "../math/SafeMath.sol";
  * typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
  * owner.
  */
-contract TokenVesting is Ownable {
+contract TokenVesting is Initializable, Ownable {
     // The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
     // therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
     // it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
@@ -46,7 +47,9 @@ contract TokenVesting is Ownable {
      * @param duration duration in seconds of the period in which the tokens will vest
      * @param revocable whether the vesting is revocable or not
      */
-    constructor (address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable) public {
+    function initialize(address beneficiary, uint256 start, uint256 cliffDuration, uint256 duration, bool revocable, address sender) public initializer {
+        Ownable.initialize(sender);
+
         require(beneficiary != address(0));
         require(cliffDuration <= duration);
         require(duration > 0);
@@ -169,4 +172,6 @@ contract TokenVesting is Ownable {
             return totalBalance.mul(block.timestamp.sub(_start)).div(_duration);
         }
     }
+
+    uint256[50] private ______gap;
 }

contracts/examples/SampleCrowdsale.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../crowdsale/validation/CappedCrowdsale.sol";
 import "../crowdsale/distribution/RefundableCrowdsale.sol";
 import "../crowdsale/emission/MintedCrowdsale.sol";
@@ -11,10 +12,13 @@ import "../token/ERC20/ERC20Detailed.sol";
  * @dev Very simple ERC20 Token that can be minted.
  * It is meant to be used in a crowdsale contract.
  */
-contract SampleCrowdsaleToken is ERC20Mintable, ERC20Detailed {
-    constructor () public ERC20Detailed("Sample Crowdsale Token", "SCT", 18) {
-        // solhint-disable-previous-line no-empty-blocks
+contract SampleCrowdsaleToken is Initializable, ERC20Mintable, ERC20Detailed {
+    function initialize(address sender) public initializer {
+        ERC20Mintable.initialize(sender);
+        ERC20Detailed.initialize("Sample Crowdsale Token", "SCT", 18);
     }
+
+    uint256[50] private ______gap;
 }
 
 /**
@@ -30,8 +34,9 @@ contract SampleCrowdsaleToken is ERC20Mintable, ERC20Detailed {
  * After adding multiple features it's good practice to run integration tests
  * to ensure that subcontracts works together as intended.
  */
-contract SampleCrowdsale is CappedCrowdsale, RefundableCrowdsale, MintedCrowdsale {
-    constructor (
+contract SampleCrowdsale is Initializable, Crowdsale, CappedCrowdsale, RefundableCrowdsale, MintedCrowdsale {
+
+    function initialize(
         uint256 openingTime,
         uint256 closingTime,
         uint256 rate,
@@ -41,13 +46,17 @@ contract SampleCrowdsale is CappedCrowdsale, RefundableCrowdsale, MintedCrowdsal
         uint256 goal
     )
         public
-        Crowdsale(rate, wallet, token)
-        CappedCrowdsale(cap)
-        TimedCrowdsale(openingTime, closingTime)
-        RefundableCrowdsale(goal)
+        initializer
     {
+        Crowdsale.initialize(rate, wallet, token);
+        CappedCrowdsale.initialize(cap);
+        TimedCrowdsale.initialize(openingTime, closingTime);
+        RefundableCrowdsale.initialize(goal);
+
         //As goal needs to be met for a successful crowdsale
         //the value needs to less or equal than a cap which is limit for accepted funds
         require(goal <= cap);
     }
+
+    uint256[50] private ______gap;
 }

contracts/examples/SimpleToken.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../token/ERC20/ERC20.sol";
 import "../token/ERC20/ERC20Detailed.sol";
 
@@ -9,14 +10,17 @@ import "../token/ERC20/ERC20Detailed.sol";
  * Note they can later distribute these tokens as they wish using `transfer` and other
  * `ERC20` functions.
  */
-contract SimpleToken is ERC20, ERC20Detailed {
+contract SimpleToken is Initializable, ERC20, ERC20Detailed {
     uint8 public constant DECIMALS = 18;
     uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(DECIMALS));
 
     /**
      * @dev Constructor that gives msg.sender all of existing tokens.
      */
-    constructor () public ERC20Detailed("SimpleToken", "SIM", DECIMALS) {
-        _mint(msg.sender, INITIAL_SUPPLY);
+    function initialize(address sender) public initializer {
+        ERC20Detailed.initialize("SimpleToken", "SIM", DECIMALS);
+        _mint(sender, INITIAL_SUPPLY);
     }
+
+    uint256[50] private ______gap;
 }

contracts/introspection/ERC165.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./IERC165.sol";
 
 /**
@@ -7,7 +8,7 @@ import "./IERC165.sol";
  * @author Matt Condon (@shrugs)
  * @dev Implements ERC165 using a lookup table.
  */
-contract ERC165 is IERC165 {
+contract ERC165 is Initializable, IERC165 {
     bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
     /*
      * 0x01ffc9a7 ===
@@ -23,14 +24,14 @@ contract ERC165 is IERC165 {
      * @dev A contract implementing SupportsInterfaceWithLookup
      * implement ERC165 itself
      */
-    constructor () internal {
+    function initialize() public initializer {
         _registerInterface(_INTERFACE_ID_ERC165);
     }
 
     /**
      * @dev implement supportsInterface(bytes4) using a lookup table
      */
-    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
+    function supportsInterface(bytes4 interfaceId) public view returns (bool) {
         return _supportedInterfaces[interfaceId];
     }
 
@@ -41,4 +42,6 @@ contract ERC165 is IERC165 {
         require(interfaceId != 0xffffffff);
         _supportedInterfaces[interfaceId] = true;
     }
+
+    uint256[50] private ______gap;
 }

contracts/lifecycle/Pausable.sol

@@ -1,18 +1,21 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../access/roles/PauserRole.sol";
 
 /**
  * @title Pausable
  * @dev Base contract which allows children to implement an emergency stop mechanism.
  */
-contract Pausable is PauserRole {
+contract Pausable is Initializable, PauserRole {
     event Paused(address account);
     event Unpaused(address account);
 
     bool private _paused;
 
-    constructor () internal {
+    function initialize(address sender) public initializer {
+        PauserRole.initialize(sender);
+
         _paused = false;
     }
 
@@ -54,4 +57,6 @@ contract Pausable is PauserRole {
         _paused = false;
         emit Unpaused(msg.sender);
     }
+
+    uint256[50] private ______gap;
 }

contracts/mocks/AllowanceCrowdsaleImpl.sol

@@ -6,9 +6,8 @@ import "../crowdsale/emission/AllowanceCrowdsale.sol";
 contract AllowanceCrowdsaleImpl is AllowanceCrowdsale {
     constructor (uint256 rate, address payable wallet, IERC20 token, address tokenWallet)
         public
-        Crowdsale(rate, wallet, token)
-        AllowanceCrowdsale(tokenWallet)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        AllowanceCrowdsale.initialize(tokenWallet);
     }
 }

contracts/mocks/CappedCrowdsaleImpl.sol

@@ -6,9 +6,8 @@ import "../crowdsale/validation/CappedCrowdsale.sol";
 contract CappedCrowdsaleImpl is CappedCrowdsale {
     constructor (uint256 rate, address payable wallet, IERC20 token, uint256 cap)
         public
-        Crowdsale(rate, wallet, token)
-        CappedCrowdsale(cap)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        CappedCrowdsale.initialize(cap);
     }
 }

contracts/mocks/CapperRoleMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../access/roles/CapperRole.sol";
 
 contract CapperRoleMock is CapperRole {
+    constructor() public {
+        CapperRole.initialize(msg.sender);
+    }
+
     function removeCapper(address account) public {
         _removeCapper(account);
     }

contracts/mocks/ConditionalEscrowMock.sol

@@ -6,6 +6,10 @@ import "../payment/escrow/ConditionalEscrow.sol";
 contract ConditionalEscrowMock is ConditionalEscrow {
     mapping(address => bool) private _allowed;
 
+    constructor() public {
+        ConditionalEscrow.initialize(msg.sender);
+    }
+
     function setAllowed(address payee, bool allowed) public {
         _allowed[payee] = allowed;
     }

contracts/mocks/CrowdsaleMock.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.5.2;
 import "../crowdsale/Crowdsale.sol";
 
 contract CrowdsaleMock is Crowdsale {
-    constructor (uint256 rate, address payable wallet, IERC20 token) public Crowdsale(rate, wallet, token) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (uint256 rate, address payable wallet, IERC20 token) public {
+        Crowdsale.initialize(rate, wallet, token);
     }
 }

contracts/mocks/ERC165Mock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../introspection/ERC165.sol";
 
 contract ERC165Mock is ERC165 {
+    constructor() public {
+        ERC165.initialize();
+    }
+
     function registerInterface(bytes4 interfaceId) public {
         _registerInterface(interfaceId);
     }

contracts/mocks/ERC20BurnableMock.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.5.2;
 import "../token/ERC20/ERC20Burnable.sol";
 
 contract ERC20BurnableMock is ERC20Burnable {
-    constructor (address initialAccount, uint256 initialBalance) public {
+    constructor(address initialAccount, uint256 initialBalance) public {
         _mint(initialAccount, initialBalance);
     }
 }

contracts/mocks/ERC20CappedMock.sol

@@ -0,0 +1,13 @@
+pragma solidity ^0.5.0;
+
+import "../token/ERC20/ERC20Capped.sol";
+import "./MinterRoleMock.sol";
+
+
+contract ERC20CappedMock is ERC20Capped, MinterRoleMock {
+
+    constructor(uint256 cap) public {
+        ERC20Capped.initialize(cap, msg.sender);
+    }
+
+}

contracts/mocks/ERC20DetailedMock.sol

@@ -6,8 +6,7 @@ import "../token/ERC20/ERC20Detailed.sol";
 contract ERC20DetailedMock is ERC20, ERC20Detailed {
     constructor (string memory name, string memory symbol, uint8 decimals)
         public
-        ERC20Detailed(name, symbol, decimals)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        ERC20Detailed.initialize(name, symbol, decimals);
     }
 }

contracts/mocks/ERC20MetadataMock.sol

@@ -1,11 +1,11 @@
-pragma solidity ^0.5.2;
+pragma solidity ^0.5.0;
 
 import "../token/ERC20/ERC20.sol";
 import "../drafts/ERC1046/ERC20Metadata.sol";
 
 contract ERC20MetadataMock is ERC20, ERC20Metadata {
-    constructor (string memory tokenURI) public ERC20Metadata(tokenURI) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (string memory tokenURI) public {
+        ERC20Metadata.initialize(tokenURI);
     }
 
     function setTokenURI(string memory tokenURI) public {

contracts/mocks/ERC20MigratorMock.sol

@@ -0,0 +1,12 @@
+pragma solidity ^0.5.0;
+
+import "../drafts/ERC20Migrator.sol";
+
+
+contract ERC20MigratorMock is ERC20Migrator {
+
+    constructor(IERC20 legacyToken) public {
+        ERC20Migrator.initialize(legacyToken);
+    }
+
+}

contracts/mocks/ERC20MintableMock.sol

@@ -4,5 +4,7 @@ import "../token/ERC20/ERC20Mintable.sol";
 import "./MinterRoleMock.sol";
 
 contract ERC20MintableMock is ERC20Mintable, MinterRoleMock {
-    // solhint-disable-previous-line no-empty-blocks
+    constructor() public {
+        ERC20Mintable.initialize(msg.sender);
+    }
 }

contracts/mocks/ERC20PausableMock.sol

@@ -6,6 +6,7 @@ import "./PauserRoleMock.sol";
 // mock class using ERC20Pausable
 contract ERC20PausableMock is ERC20Pausable, PauserRoleMock {
     constructor (address initialAccount, uint initialBalance) public {
+        ERC20Pausable.initialize(msg.sender);
         _mint(initialAccount, initialBalance);
     }
 }

contracts/mocks/ERC721FullMock.sol

@@ -11,8 +11,12 @@ import "../token/ERC721/ERC721Burnable.sol";
  * checking token existence, removal of a token from an address
  */
 contract ERC721FullMock is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
-    constructor (string memory name, string memory symbol) public ERC721Mintable() ERC721Full(name, symbol) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (string memory name, string memory symbol) public {
+        ERC721.initialize();
+        ERC721Metadata.initialize(name, symbol);
+        ERC721Enumerable.initialize();
+        ERC721Mintable.initialize(msg.sender);
+        ERC721MetadataMintable.initialize(msg.sender);
     }
 
     function exists(uint256 tokenId) public view returns (bool) {

contracts/mocks/ERC721MintableBurnableImpl.sol

@@ -9,7 +9,11 @@ import "../token/ERC721/ERC721Burnable.sol";
  * @title ERC721MintableBurnableImpl
  */
 contract ERC721MintableBurnableImpl is ERC721Full, ERC721Mintable, ERC721MetadataMintable, ERC721Burnable {
-    constructor () public ERC721Mintable() ERC721Full("Test", "TEST") {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor () public {
+        ERC721.initialize();
+        ERC721Metadata.initialize("Test", "TEST");
+        ERC721Enumerable.initialize();
+        ERC721Mintable.initialize(msg.sender);
+        ERC721MetadataMintable.initialize(msg.sender);
     }
 }

contracts/mocks/ERC721Mock.sol

@@ -7,6 +7,10 @@ import "../token/ERC721/ERC721.sol";
  * This mock just provides a public mint and burn functions for testing purposes
  */
 contract ERC721Mock is ERC721 {
+    constructor() public {
+        ERC721.initialize();
+    }
+
     function mint(address to, uint256 tokenId) public {
         _mint(to, tokenId);
     }

contracts/mocks/ERC721PausableMock.sol

@@ -8,6 +8,11 @@ import "./PauserRoleMock.sol";
  * This mock just provides a public mint, burn and exists functions for testing purposes
  */
 contract ERC721PausableMock is ERC721Pausable, PauserRoleMock {
+    constructor() public {
+        ERC721.initialize();
+        ERC721Pausable.initialize(msg.sender);
+    }
+
     function mint(address to, uint256 tokenId) public {
         super._mint(to, tokenId);
     }

contracts/mocks/EscrowMock.sol

@@ -0,0 +1,9 @@
+pragma solidity ^0.5.0;
+
+import "../payment/escrow/Escrow.sol";
+
+contract EscrowMock is Escrow {
+    constructor() public {
+        Escrow.initialize(msg.sender);
+    }
+}

contracts/mocks/FinalizableCrowdsaleImpl.sol

@@ -6,9 +6,8 @@ import "../crowdsale/distribution/FinalizableCrowdsale.sol";
 contract FinalizableCrowdsaleImpl is FinalizableCrowdsale {
     constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address payable wallet, IERC20 token)
         public
-        Crowdsale(rate, wallet, token)
-        TimedCrowdsale(openingTime, closingTime)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        TimedCrowdsale.initialize(openingTime, closingTime);
     }
 }

contracts/mocks/ForceEther.sol

@@ -0,0 +1,18 @@
+pragma solidity ^0.5.0;
+
+
+// @title Force Ether into a contract.
+// @notice  even
+// if the contract is not payable.
+// @notice To use, construct the contract with the target as argument.
+// @author Remco Bloemen <remco@neufund.org>
+contract ForceEther {
+
+    constructor() public payable {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    function destroyAndSend(address payable recipient) public {
+        selfdestruct(recipient);
+    }
+}

contracts/mocks/IncreasingPriceCrowdsaleImpl.sol

@@ -13,10 +13,9 @@ contract IncreasingPriceCrowdsaleImpl is IncreasingPriceCrowdsale {
         uint256 finalRate
     )
         public
-        Crowdsale(initialRate, wallet, token)
-        TimedCrowdsale(openingTime, closingTime)
-        IncreasingPriceCrowdsale(initialRate, finalRate)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(initialRate, wallet, token);
+        TimedCrowdsale.initialize(openingTime, closingTime);
+        IncreasingPriceCrowdsale.initialize(initialRate, finalRate);
     }
 }

contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol

@@ -5,7 +5,8 @@ import "../crowdsale/validation/IndividuallyCappedCrowdsale.sol";
 import "./CapperRoleMock.sol";
 
 contract IndividuallyCappedCrowdsaleImpl is IndividuallyCappedCrowdsale, CapperRoleMock {
-    constructor (uint256 rate, address payable wallet, IERC20 token) public Crowdsale(rate, wallet, token) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (uint256 rate, address payable wallet, IERC20 token) public {
+        Crowdsale.initialize(rate, wallet, token);
+        IndividuallyCappedCrowdsale.initialize(msg.sender);
     }
 }

contracts/mocks/MessageHelper.sol

@@ -0,0 +1,51 @@
+pragma solidity ^0.5.0;
+
+
+contract MessageHelper {
+
+    event Show(bytes32 b32, uint256 number, string text);
+    event Buy(bytes32 b32, uint256 number, string text, uint256 value);
+
+    function showMessage(
+        bytes32 _message,
+        uint256 _number,
+        string memory _text
+    )
+        public
+        returns (bool)
+    {
+        emit Show(_message, _number, _text);
+        return true;
+    }
+
+    function buyMessage(
+        bytes32 _message,
+        uint256 _number,
+        string memory _text
+    )
+        public
+        payable
+        returns (bool)
+    {
+        emit Buy(
+            _message,
+            _number,
+            _text,
+            msg.value);
+        return true;
+    }
+
+    function fail() public {
+        require(false);
+    }
+
+    function call(address _to, bytes memory _data) public returns (bool) {
+        // solhint-disable-next-line security/avoid-low-level-calls
+        (bool success,) = _to.call(_data);
+        if (success)
+            return true;
+        else
+            return false;
+    }
+
+}

contracts/mocks/MintedCrowdsaleImpl.sol

@@ -4,7 +4,7 @@ import "../token/ERC20/ERC20Mintable.sol";
 import "../crowdsale/emission/MintedCrowdsale.sol";
 
 contract MintedCrowdsaleImpl is MintedCrowdsale {
-    constructor (uint256 rate, address payable wallet, ERC20Mintable token) public Crowdsale(rate, wallet, token) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (uint256 rate, address payable wallet, ERC20Mintable token) public {
+        Crowdsale.initialize(rate, wallet, token);
     }
 }

contracts/mocks/MinterRoleMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../access/roles/MinterRole.sol";
 
 contract MinterRoleMock is MinterRole {
+    constructor() public {
+        MinterRole.initialize(msg.sender);
+    }
+
     function removeMinter(address account) public {
         _removeMinter(account);
     }

contracts/mocks/OwnableMock.sol

@@ -3,5 +3,7 @@ pragma solidity ^0.5.2;
 import "../ownership/Ownable.sol";
 
 contract OwnableMock is Ownable {
-    // solhint-disable-previous-line no-empty-blocks
+    constructor() public {
+        Ownable.initialize(msg.sender);
+    }
 }

contracts/mocks/PausableCrowdsaleImpl.sol

@@ -4,7 +4,8 @@ import "../token/ERC20/ERC20.sol";
 import "../crowdsale/validation/PausableCrowdsale.sol";
 
 contract PausableCrowdsaleImpl is PausableCrowdsale {
-    constructor (uint256 _rate, address payable _wallet, ERC20 _token) public Crowdsale(_rate, _wallet, _token) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (uint256 _rate, address payable _wallet, ERC20 _token) public {
+        Crowdsale.initialize(_rate, _wallet, _token);
+        PausableCrowdsale.initialize(msg.sender);
     }
 }

contracts/mocks/PausableMock.sol

@@ -9,6 +9,8 @@ contract PausableMock is Pausable, PauserRoleMock {
     uint256 public count;
 
     constructor () public {
+        Pausable.initialize(msg.sender);
+
         drasticMeasureTaken = false;
         count = 0;
     }

contracts/mocks/PauserRoleMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../access/roles/PauserRole.sol";
 
 contract PauserRoleMock is PauserRole {
+    constructor () public {
+        PauserRole.initialize(msg.sender);
+    }
+
     function removePauser(address account) public {
         _removePauser(account);
     }

contracts/mocks/PaymentSplitterMock.sol

@@ -0,0 +1,9 @@
+pragma solidity ^0.5.0;
+
+import "../payment/PaymentSplitter.sol";
+
+contract PaymentSplitterMock is PaymentSplitter {
+    constructor(address[] memory payees, uint256[] memory shares) public {
+        PaymentSplitter.initialize(payees, shares);
+    }
+}

contracts/mocks/PostDeliveryCrowdsaleImpl.sol

@@ -6,9 +6,8 @@ import "../crowdsale/distribution/PostDeliveryCrowdsale.sol";
 contract PostDeliveryCrowdsaleImpl is PostDeliveryCrowdsale {
     constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address payable wallet, IERC20 token)
         public
-        TimedCrowdsale(openingTime, closingTime)
-        Crowdsale(rate, wallet, token)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        TimedCrowdsale.initialize(openingTime, closingTime);
     }
 }

contracts/mocks/PullPaymentMock.sol

@@ -5,7 +5,7 @@ import "../payment/PullPayment.sol";
 // mock class using PullPayment
 contract PullPaymentMock is PullPayment {
     constructor () public payable {
-        // solhint-disable-previous-line no-empty-blocks
+        PullPayment.initialize();
     }
 
     // test helper function to call asyncTransfer

contracts/mocks/ReentrancyMock.sol

@@ -7,6 +7,7 @@ contract ReentrancyMock is ReentrancyGuard {
     uint256 public counter;
 
     constructor () public {
+        ReentrancyGuard.initialize();
         counter = 0;
     }
 

contracts/mocks/RefundEscrowMock.sol

@@ -0,0 +1,9 @@
+pragma solidity ^0.5.0;
+
+import "../payment/escrow/RefundEscrow.sol";
+
+contract RefundEscrowMock is RefundEscrow {
+    constructor(address payable beneficiary) public {
+        RefundEscrow.initialize(beneficiary, msg.sender);
+    }
+}

contracts/mocks/RefundableCrowdsaleImpl.sol

@@ -3,7 +3,7 @@ pragma solidity ^0.5.2;
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/RefundableCrowdsale.sol";
 
-contract RefundableCrowdsaleImpl is RefundableCrowdsale {
+contract RefundableCrowdsaleImpl is Crowdsale, TimedCrowdsale, RefundableCrowdsale {
     constructor (
         uint256 openingTime,
         uint256 closingTime,
@@ -13,10 +13,9 @@ contract RefundableCrowdsaleImpl is RefundableCrowdsale {
         uint256 goal
     )
         public
-        Crowdsale(rate, wallet, token)
-        TimedCrowdsale(openingTime, closingTime)
-        RefundableCrowdsale(goal)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        TimedCrowdsale.initialize(openingTime, closingTime);
+        RefundableCrowdsale.initialize(goal);
     }
 }

contracts/mocks/RefundablePostDeliveryCrowdsaleImpl.sol

@@ -13,10 +13,9 @@ contract RefundablePostDeliveryCrowdsaleImpl is RefundablePostDeliveryCrowdsale
         uint256 goal
     )
         public
-        Crowdsale(rate, wallet, token)
-        TimedCrowdsale(openingTime, closingTime)
-        RefundableCrowdsale(goal)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        TimedCrowdsale.initialize(openingTime, closingTime);
+        RefundableCrowdsale.initialize(goal);
     }
 }

contracts/mocks/SampleCrowdsaleMock.sol

@@ -0,0 +1,26 @@
+pragma solidity ^0.5.0;
+
+import "../examples/SampleCrowdsale.sol";
+
+
+contract SampleCrowdsaleTokenMock is SampleCrowdsaleToken {
+    constructor() public {
+        SampleCrowdsaleToken.initialize(msg.sender);
+    }
+}
+
+contract SampleCrowdsaleMock is SampleCrowdsale {
+    constructor(
+        uint256 openingTime,
+        uint256 closingTime,
+        uint256 rate,
+        address payable wallet,
+        uint256 cap,
+        ERC20Mintable token,
+        uint256 goal
+    )
+        public
+    {
+        SampleCrowdsale.initialize(openingTime, closingTime, rate, wallet, cap, token, goal);
+    }
+}

contracts/mocks/SecondaryMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../ownership/Secondary.sol";
 
 contract SecondaryMock is Secondary {
+    constructor() public {
+        Secondary.initialize(msg.sender);
+    }
+
     function onlyPrimaryMock() public view onlyPrimary {
         // solhint-disable-previous-line no-empty-blocks
     }

contracts/mocks/SignatureBouncerMock.sol

@@ -4,6 +4,10 @@ import "../drafts/SignatureBouncer.sol";
 import "./SignerRoleMock.sol";
 
 contract SignatureBouncerMock is SignatureBouncer, SignerRoleMock {
+    constructor() public {
+        SignatureBouncer.initialize(msg.sender);
+    }
+
     function checkValidSignature(address account, bytes memory signature)
         public view returns (bool)
     {

contracts/mocks/SignerRoleMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../access/roles/SignerRole.sol";
 
 contract SignerRoleMock is SignerRole {
+    constructor() public {
+        SignerRole.initialize(msg.sender);
+    }
+
     function removeSigner(address account) public {
         _removeSigner(account);
     }

contracts/mocks/SimpleTokenMock.sol

@@ -0,0 +1,9 @@
+pragma solidity ^0.5.0;
+
+import "../examples/SimpleToken.sol";
+
+contract SimpleTokenMock is SimpleToken {
+    constructor() public {
+        SimpleToken.initialize(msg.sender);
+    }
+}

contracts/mocks/TimedCrowdsaleImpl.sol

@@ -6,10 +6,9 @@ import "../crowdsale/validation/TimedCrowdsale.sol";
 contract TimedCrowdsaleImpl is TimedCrowdsale {
     constructor (uint256 openingTime, uint256 closingTime, uint256 rate, address payable wallet, IERC20 token)
         public
-        Crowdsale(rate, wallet, token)
-        TimedCrowdsale(openingTime, closingTime)
     {
-        // solhint-disable-previous-line no-empty-blocks
+        Crowdsale.initialize(rate, wallet, token);
+        TimedCrowdsale.initialize(openingTime, closingTime);
     }
 
     function extendTime(uint256 closingTime) public {

contracts/mocks/TokenTimelockMock.sol

@@ -0,0 +1,13 @@
+pragma solidity ^0.5.0;
+
+import "../token/ERC20/TokenTimelock.sol";
+
+contract TokenTimelockMock is TokenTimelock {
+    constructor(
+        IERC20 token,
+        address beneficiary,
+        uint256 releaseTime
+    ) public {
+        TokenTimelock.initialize(token, beneficiary, releaseTime);
+    }
+}

contracts/mocks/TokenVestingMock.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.5.0;
+
+import "../drafts/TokenVesting.sol";
+
+contract TokenVestingMock is TokenVesting {
+    constructor(
+        address beneficiary,
+        uint256 start,
+        uint256 cliffDuration,
+        uint256 duration,
+        bool revocable
+    ) public {
+        TokenVesting.initialize(
+            beneficiary,
+            start,
+            cliffDuration,
+            duration,
+            revocable,
+            msg.sender
+        );
+    }
+}

contracts/mocks/WhitelistAdminRoleMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../access/roles/WhitelistAdminRole.sol";
 
 contract WhitelistAdminRoleMock is WhitelistAdminRole {
+    constructor () public {
+        WhitelistAdminRole.initialize(msg.sender);
+    }
+
     function removeWhitelistAdmin(address account) public {
         _removeWhitelistAdmin(account);
     }

contracts/mocks/WhitelistCrowdsaleImpl.sol

@@ -6,7 +6,8 @@ import "../crowdsale/Crowdsale.sol";
 
 
 contract WhitelistCrowdsaleImpl is Crowdsale, WhitelistCrowdsale {
-    constructor (uint256 _rate, address payable _wallet, IERC20 _token) public Crowdsale(_rate, _wallet, _token) {
-        // solhint-disable-previous-line no-empty-blocks
+    constructor (uint256 _rate, address payable _wallet, IERC20 _token) public {
+        Crowdsale.initialize(_rate, _wallet, _token);
+        WhitelistCrowdsale.initialize(msg.sender);
     }
 }

contracts/mocks/WhitelistedRoleMock.sol

@@ -3,6 +3,10 @@ pragma solidity ^0.5.2;
 import "../access/roles/WhitelistedRole.sol";
 
 contract WhitelistedRoleMock is WhitelistedRole {
+    constructor() public {
+        WhitelistedRole.initialize(msg.sender);
+    }
+
     function onlyWhitelistedMock() public view onlyWhitelisted {
         // solhint-disable-previous-line no-empty-blocks
     }

contracts/ownership/Ownable.sol

@@ -1,11 +1,13 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 /**
  * @title Ownable
  * @dev The Ownable contract has an owner address, and provides basic authorization control
  * functions, this simplifies the implementation of "user permissions".
  */
-contract Ownable {
+contract Ownable is Initializable {
     address private _owner;
 
     event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
@@ -14,8 +16,8 @@ contract Ownable {
      * @dev The Ownable constructor sets the original `owner` of the contract to the sender
      * account.
      */
-    constructor () internal {
-        _owner = msg.sender;
+    function initialize(address sender) public initializer {
+        _owner = sender;
         emit OwnershipTransferred(address(0), _owner);
     }
 
@@ -70,4 +72,6 @@ contract Ownable {
         emit OwnershipTransferred(_owner, newOwner);
         _owner = newOwner;
     }
+
+    uint256[50] private ______gap;
 }

contracts/ownership/Secondary.sol

@@ -1,10 +1,12 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 /**
  * @title Secondary
  * @dev A Secondary contract can only be used by its primary account (the one that created it)
  */
-contract Secondary {
+contract Secondary is Initializable {
     address private _primary;
 
     event PrimaryTransferred(
@@ -14,8 +16,8 @@ contract Secondary {
     /**
      * @dev Sets the primary account to the one that is creating the Secondary contract.
      */
-    constructor () internal {
-        _primary = msg.sender;
+    function initialize(address sender) public initializer {
+        _primary = sender;
         emit PrimaryTransferred(_primary);
     }
 
@@ -43,4 +45,6 @@ contract Secondary {
         _primary = recipient;
         emit PrimaryTransferred(_primary);
     }
+
+    uint256[50] private ______gap;
 }

contracts/payment/PaymentSplitter.sol

@@ -1,5 +1,7 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "../math/SafeMath.sol";
 
 /**
@@ -7,7 +9,7 @@ import "../math/SafeMath.sol";
  * @dev This contract can be used when payments need to be received by a group
  * of people and split proportionately to some number of shares they own.
  */
-contract PaymentSplitter {
+contract PaymentSplitter is Initializable {
     using SafeMath for uint256;
 
     event PayeeAdded(address account, uint256 shares);
@@ -24,7 +26,7 @@ contract PaymentSplitter {
     /**
      * @dev Constructor
      */
-    constructor (address[] memory payees, uint256[] memory shares) public payable {
+    function initialize(address[] memory payees, uint256[] memory shares) public payable initializer {
         require(payees.length == shares.length);
         require(payees.length > 0);
 
@@ -109,4 +111,6 @@ contract PaymentSplitter {
         _totalShares = _totalShares.add(shares_);
         emit PayeeAdded(account, shares_);
     }
+
+    uint256[50] private ______gap;
 }

contracts/payment/PullPayment.sol

@@ -1,5 +1,7 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "./escrow/Escrow.sol";
 
 /**
@@ -7,11 +9,15 @@ import "./escrow/Escrow.sol";
  * @dev Base contract supporting async send for pull payments. Inherit from this
  * contract and use _asyncTransfer instead of send or transfer.
  */
-contract PullPayment {
+contract PullPayment is Initializable {
     Escrow private _escrow;
 
-    constructor () internal {
-        _escrow = new Escrow();
+    function initialize() public initializer {
+        // conditional added to make initializer idempotent in case of diamond inheritance
+        if (address(_escrow) == address(0)) {
+            _escrow = new Escrow();
+            _escrow.initialize(address(this));
+        }
     }
 
     /**
@@ -38,4 +44,6 @@ contract PullPayment {
     function _asyncTransfer(address dest, uint256 amount) internal {
         _escrow.deposit.value(amount)(dest);
     }
+
+    uint256[50] private ______gap;
 }

contracts/payment/escrow/ConditionalEscrow.sol

@@ -7,7 +7,11 @@ import "./Escrow.sol";
  * @dev Base abstract escrow to only allow withdrawal if a condition is met.
  * @dev Intended usage: See Escrow.sol. Same usage guidelines apply here.
  */
-contract ConditionalEscrow is Escrow {
+contract ConditionalEscrow is Initializable, Escrow {
+    function initialize(address sender) public initializer {
+        Escrow.initialize(sender);
+    }
+
     /**
      * @dev Returns whether an address is allowed to withdraw their funds. To be
      * implemented by derived contracts.
@@ -19,4 +23,6 @@ contract ConditionalEscrow is Escrow {
         require(withdrawalAllowed(payee));
         super.withdraw(payee);
     }
+
+    uint256[50] private ______gap;
 }

contracts/payment/escrow/Escrow.sol

@@ -15,7 +15,7 @@ import "../../ownership/Secondary.sol";
   * payment method should be its primary, and provide public methods redirecting
   * to the escrow's deposit and withdraw.
   */
-contract Escrow is Secondary {
+contract Escrow is Initializable, Secondary {
     using SafeMath for uint256;
 
     event Deposited(address indexed payee, uint256 weiAmount);
@@ -23,6 +23,10 @@ contract Escrow is Secondary {
 
     mapping(address => uint256) private _deposits;
 
+    function initialize(address sender) public initializer {
+        Secondary.initialize(sender);
+    }
+
     function depositsOf(address payee) public view returns (uint256) {
         return _deposits[payee];
     }
@@ -51,4 +55,6 @@ contract Escrow is Secondary {
 
         emit Withdrawn(payee, payment);
     }
+
+    uint256[50] private ______gap;
 }

contracts/payment/escrow/RefundEscrow.sol

@@ -1,5 +1,7 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
 import "./ConditionalEscrow.sol";
 
 /**
@@ -13,7 +15,7 @@ import "./ConditionalEscrow.sol";
  * with RefundEscrow will be made through the primary contract. See the
  * RefundableCrowdsale contract for an example of RefundEscrow’s use.
  */
-contract RefundEscrow is ConditionalEscrow {
+contract RefundEscrow is Initializable, ConditionalEscrow {
     enum State { Active, Refunding, Closed }
 
     event RefundsClosed();
@@ -26,7 +28,9 @@ contract RefundEscrow is ConditionalEscrow {
      * @dev Constructor.
      * @param beneficiary The beneficiary of the deposits.
      */
-    constructor (address payable beneficiary) public {
+    function initialize(address payable beneficiary, address sender) public initializer {
+        ConditionalEscrow.initialize(sender);
+
         require(beneficiary != address(0));
         _beneficiary = beneficiary;
         _state = State.Active;
@@ -89,4 +93,6 @@ contract RefundEscrow is ConditionalEscrow {
     function withdrawalAllowed(address) public view returns (bool) {
         return _state == State.Refunding;
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/ERC20.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./IERC20.sol";
 import "../../math/SafeMath.sol";
 
@@ -15,7 +16,7 @@ import "../../math/SafeMath.sol";
  * all accounts just by listening to said events. Note that this isn't required by the specification, and other
  * compliant implementations may not do it.
  */
-contract ERC20 is IERC20 {
+contract ERC20 is Initializable, IERC20 {
     using SafeMath for uint256;
 
     mapping (address => uint256) private _balances;
@@ -187,4 +188,6 @@ contract ERC20 is IERC20 {
         _burn(account, value);
         _approve(account, msg.sender, _allowed[account][msg.sender].sub(value));
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/ERC20Burnable.sol

@@ -1,12 +1,13 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./ERC20.sol";
 
 /**
  * @title Burnable Token
  * @dev Token that can be irreversibly burned (destroyed).
  */
-contract ERC20Burnable is ERC20 {
+contract ERC20Burnable is Initializable, ERC20 {
     /**
      * @dev Burns a specific amount of tokens.
      * @param value The amount of token to be burned.
@@ -23,4 +24,6 @@ contract ERC20Burnable is ERC20 {
     function burnFrom(address from, uint256 value) public {
         _burnFrom(from, value);
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/ERC20Capped.sol

@@ -1,15 +1,18 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./ERC20Mintable.sol";
 
 /**
  * @title Capped token
  * @dev Mintable token with a token cap.
  */
-contract ERC20Capped is ERC20Mintable {
+contract ERC20Capped is Initializable, ERC20Mintable {
     uint256 private _cap;
 
-    constructor (uint256 cap) public {
+    function initialize(uint256 cap, address sender) public initializer {
+        ERC20Mintable.initialize(sender);
+
         require(cap > 0);
         _cap = cap;
     }
@@ -25,4 +28,6 @@ contract ERC20Capped is ERC20Mintable {
         require(totalSupply().add(value) <= _cap);
         super._mint(account, value);
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/ERC20Detailed.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./IERC20.sol";
 
 /**
@@ -8,12 +9,12 @@ import "./IERC20.sol";
  * All the operations are done using the smallest and indivisible token unit,
  * just as on Ethereum all the operations are done in wei.
  */
-contract ERC20Detailed is IERC20 {
+contract ERC20Detailed is Initializable, IERC20 {
     string private _name;
     string private _symbol;
     uint8 private _decimals;
 
-    constructor (string memory name, string memory symbol, uint8 decimals) public {
+    function initialize(string memory name, string memory symbol, uint8 decimals) public initializer {
         _name = name;
         _symbol = symbol;
         _decimals = decimals;
@@ -39,4 +40,6 @@ contract ERC20Detailed is IERC20 {
     function decimals() public view returns (uint8) {
         return _decimals;
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/ERC20Mintable.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./ERC20.sol";
 import "../../access/roles/MinterRole.sol";
 
@@ -7,7 +8,11 @@ import "../../access/roles/MinterRole.sol";
  * @title ERC20Mintable
  * @dev ERC20 minting logic
  */
-contract ERC20Mintable is ERC20, MinterRole {
+contract ERC20Mintable is Initializable, ERC20, MinterRole {
+    function initialize(address sender) public initializer {
+        MinterRole.initialize(sender);
+    }
+
     /**
      * @dev Function to mint tokens
      * @param to The address that will receive the minted tokens.
@@ -18,4 +23,6 @@ contract ERC20Mintable is ERC20, MinterRole {
         _mint(to, value);
         return true;
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/ERC20Pausable.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./ERC20.sol";
 import "../../lifecycle/Pausable.sol";
 
@@ -7,7 +8,11 @@ import "../../lifecycle/Pausable.sol";
  * @title Pausable token
  * @dev ERC20 modified with pausable transfers.
  */
-contract ERC20Pausable is ERC20, Pausable {
+contract ERC20Pausable is Initializable, ERC20, Pausable {
+    function initialize(address sender) public initializer {
+        Pausable.initialize(sender);
+    }
+
     function transfer(address to, uint256 value) public whenNotPaused returns (bool) {
         return super.transfer(to, value);
     }
@@ -27,4 +32,6 @@ contract ERC20Pausable is ERC20, Pausable {
     function decreaseAllowance(address spender, uint subtractedValue) public whenNotPaused returns (bool success) {
         return super.decreaseAllowance(spender, subtractedValue);
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC20/StandaloneERC20.sol

@@ -0,0 +1,63 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "./ERC20Detailed.sol";
+import "./ERC20Mintable.sol";
+import "./ERC20Pausable.sol";
+
+
+/**
+ * @title Standard ERC20 token, with minting and pause functionality.
+ *
+ */
+contract StandaloneERC20 is Initializable, ERC20Detailed, ERC20Mintable, ERC20Pausable {
+    function initialize(
+        string memory name, string memory symbol, uint8 decimals, uint256 initialSupply, address initialHolder,
+        address[] memory minters, address[] memory pausers
+    ) public initializer {
+        ERC20Detailed.initialize(name, symbol, decimals);
+
+        // Mint the initial supply
+        _mint(initialHolder, initialSupply);
+
+        // Initialize the minter and pauser roles, and renounce them
+        ERC20Mintable.initialize(address(this));
+        _removeMinter(address(this));
+
+        ERC20Pausable.initialize(address(this));
+        _removePauser(address(this));
+
+        // Add the requested minters and pausers (this can be done after renouncing since
+        // these are the internal calls)
+        for (uint256 i = 0; i < minters.length; ++i) {
+            _addMinter(minters[i]);
+        }
+
+        for (uint256 i = 0; i < pausers.length; ++i) {
+            _addPauser(pausers[i]);
+        }
+    }
+
+    function initialize(
+        string memory name, string memory symbol, uint8 decimals, address[] memory minters, address[] memory pausers
+    ) public initializer {
+        ERC20Detailed.initialize(name, symbol, decimals);
+
+        // Initialize the minter and pauser roles, and renounce them
+        ERC20Mintable.initialize(address(this));
+        _removeMinter(address(this));
+
+        ERC20Pausable.initialize(address(this));
+        _removePauser(address(this));
+
+        // Add the requested minters and pausers (this can be done after renouncing since
+        // these are the internal calls)
+        for (uint256 i = 0; i < minters.length; ++i) {
+            _addMinter(minters[i]);
+        }
+
+        for (uint256 i = 0; i < pausers.length; ++i) {
+            _addPauser(pausers[i]);
+        }
+    }
+}

contracts/token/ERC20/TokenTimelock.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./SafeERC20.sol";
 
 /**
@@ -7,7 +8,7 @@ import "./SafeERC20.sol";
  * @dev TokenTimelock is a token holder contract that will allow a
  * beneficiary to extract the tokens after a given release time
  */
-contract TokenTimelock {
+contract TokenTimelock is Initializable {
     using SafeERC20 for IERC20;
 
     // ERC20 basic token contract being held
@@ -19,7 +20,7 @@ contract TokenTimelock {
     // timestamp when token release is enabled
     uint256 private _releaseTime;
 
-    constructor (IERC20 token, address beneficiary, uint256 releaseTime) public {
+    function initialize (IERC20 token, address beneficiary, uint256 releaseTime) public initializer {
         // solhint-disable-next-line not-rely-on-time
         require(releaseTime > block.timestamp);
         _token = token;
@@ -60,4 +61,6 @@ contract TokenTimelock {
 
         _token.safeTransfer(_beneficiary, amount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC721/ERC721.sol

@@ -1,5 +1,6 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./IERC721.sol";
 import "./IERC721Receiver.sol";
 import "../../math/SafeMath.sol";
@@ -11,7 +12,7 @@ import "../../introspection/ERC165.sol";
  * @title ERC721 Non-Fungible Token Standard basic implementation
  * @dev see https://eips.ethereum.org/EIPS/eip-721
  */
-contract ERC721 is ERC165, IERC721 {
+contract ERC721 is Initializable, ERC165, IERC721 {
     using SafeMath for uint256;
     using Address for address;
     using Counters for Counters.Counter;
@@ -46,11 +47,17 @@ contract ERC721 is ERC165, IERC721 {
      *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
      */
 
-    constructor () public {
+    function initialize() public initializer {
+        ERC165.initialize();
+
         // register the supported interfaces to conform to ERC721 via ERC165
         _registerInterface(_INTERFACE_ID_ERC721);
     }
 
+    function _hasBeenInitialized() internal view returns (bool) {
+        return supportsInterface(_INTERFACE_ID_ERC721);
+    }
+
     /**
      * @dev Gets the balance of the specified address
      * @param owner address to query the balance of
@@ -283,4 +290,6 @@ contract ERC721 is ERC165, IERC721 {
             _tokenApprovals[tokenId] = address(0);
         }
     }
+
+    uint256[50] private ______gap;
 }

contracts/token/ERC721/ERC721Burnable.sol

@@ -1,12 +1,13 @@
 pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./ERC721.sol";
 
 /**
  * @title ERC721 Burnable Token
  * @dev ERC721 Token that can be irreversibly burned (destroyed).
  */
-contract ERC721Burnable is ERC721 {
+contract ERC721Burnable is Initializable, ERC721 {
     /**
      * @dev Burns a specific ERC721 token.
      * @param tokenId uint256 id of the ERC721 token to be burned.
@@ -15,4 +16,6 @@ contract ERC721Burnable is ERC721 {
         require(_isApprovedOrOwner(msg.sender, tokenId));
         _burn(tokenId);
     }
+
+    uint256[50] private ______gap;
 }