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

.github/PULL_REQUEST_TEMPLATE.md

@@ -16,6 +16,7 @@ Fixes #
     (https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/CONTRIBUTING.md),
   - added tests where applicable to test new functionality,
   - made sure that your contracts are well-documented,
-  - run the JS/Solidity linters and fixed any issues (`npm run lint:fix`), and
+  - run the Solidity linter (`npm run lint:sol`) and fixed any issues,
+  - run the JS linter and fixed any issues (`npm run lint:fix`), and
   - updated the changelog, if applicable.
 -->

.gitignore

@@ -32,11 +32,13 @@ npm-debug.log
 # truffle build directory
 build/
 
-# lol macs
-.DS_Store/
+# macOS
+.DS_Store
 
 # truffle
 .node-xmlhttprequest-*
 
-# Temporary directory for 0.5.x compilation
-solc-0.5
+.openzeppelin/.session
+
+# IntelliJ IDE
+.idea

.node-version

@@ -1 +0,0 @@
-v8.9.1

.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,9 +1,42 @@
 # Changelog
 
-## 2.1.1 (2019-04-01)
+## 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:
+ * `ERC20Snapshot`: create snapshots on demand of the token balances and total supply, to later retrieve and e.g. calculate dividends at a past time. ([#1617](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1617))
+ * `SafeERC20`: `ERC20` contracts with no return value (i.e. that revert on failure) are now supported. ([#1655](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/))
+ * `ERC20`: added internal `_approve(address owner, address spender, uint256 value)`, allowing derived contracts to set the allowance of arbitrary accounts. ([#1609](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1609))
+ * `ERC20Metadata`: added internal `_setTokenURI(string memory tokenURI)`. ([#1618](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1618))
+ * `TimedCrowdsale`: added internal `_extendTime(uint256 newClosingTime)` as well as `TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime)` event allowing to extend the crowdsale, as long as it hasn't already closed.
+
+### Improvements:
+ * Upgraded the minimum compiler version to v0.5.2: this removes many Solidity warnings that were false positives. ([#1606](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1606))
+ * `ECDSA`: `recover` no longer accepts malleable signatures (those using upper-range values for `s`, or 0/1 for `v`). ([#1622](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1622))
+ * `ERC721`'s transfers are now more gas efficient due to removal of unnecessary `SafeMath` calls. ([#1610](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1610))
+ * `Counter`'s API has been improved, and is now used by `ERC721` (though it is still in `drafts`). ([#1610](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1610))
+ * Fixed variable shadowing issues. ([#1606](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1606))
+
+### Bugfixes:
+ * (minor) `SafeERC20`: `safeApprove` wasn't properly checking for a zero allowance when attempting to set a non-zero allowance. ([#1647](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1647))
+
+### Breaking changes:
+ * `TokenMetadata` (in drafts) has been renamed to `ERC20Metadata`. ([#1618](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1618))
+
+## 2.1.3 (2019-02-26)
+ * Backported `SafeERC20.safeApprove` bugfix. ([#1647](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1647))
+
+## 2.1.2 (2019-01-17)
+ * Removed most of the test suite from the npm package, except `PublicRole.behavior.js`, which may be useful to users testing their own `Roles`.
+
+## 2.1.1 (2019-01-04)
  * Version bump to avoid conflict in the npm registry.
 
-## 2.1.0 (2019-04-01)
+## 2.1.0 (2019-01-04)
 
 ### New features:
  * Now targeting the 0.5.x line of Solidity compilers. For 0.4.24 support, use version 2.0 of OpenZeppelin.

README.md

@@ -1,42 +1,100 @@
 # <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.4.24;
+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 diferent 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.
 
 Please report any security issues you find to security@openzeppelin.org.
 
@@ -48,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

RELEASING.md

@@ -51,12 +51,15 @@ git checkout release-vX.Y.Z
 git pull upstream
 ```
 
+Before starting the release process, make one final commit to CHANGELOG.md, including the date of the release.
+
 Change the version string in `package.json`, `package-lock.json` and `ethpm.json` removing the "-rc.R" suffix. Commit these changes and tag the commit as `vX.Y.Z`.
 
 ```
 git add package.json package-lock.json ethpm.json
 git commit -m "Release vX.Y.Z"
 git tag -a vX.Y.Z
+git push upstream release-vX.Y.Z
 git push upstream vX.Y.Z
 ```
 

contracts/access/Roles.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title Roles

contracts/access/roles/CapperRole.sol

@@ -1,8 +1,10 @@
-pragma solidity ^0.5.0;
+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.0;
+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.0;
+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.0;
+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,4 +1,6 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 
 import "../Roles.sol";
 
@@ -6,7 +8,7 @@ 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,4 +1,6 @@
-pragma solidity ^0.5.0;
+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.0;
+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";
@@ -11,13 +12,13 @@ import "../utils/ReentrancyGuard.sol";
  * allowing investors to purchase tokens with ether. This contract implements
  * such functionality in its most fundamental form and can be extended to provide additional
  * functionality and/or custom behavior.
- * The external interface represents the basic interface for purchasing tokens, and conform
- * the base architecture for crowdsales. They are *not* intended to be modified / overridden.
+ * The external interface represents the basic interface for purchasing tokens, and conforms
+ * the base architecture for crowdsales. It is *not* intended to be modified / overridden.
  * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
  * 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));
@@ -65,7 +66,7 @@ contract Crowdsale is ReentrancyGuard {
 
     /**
      * @dev fallback function ***DO NOT OVERRIDE***
-     * Note that other contracts will transfer fund with a base gas stipend
+     * Note that other contracts will transfer funds with a base gas stipend
      * of 2300, which is not enough to call buyTokens. Consider calling
      * buyTokens directly when purchasing tokens from a contract.
      */
@@ -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,24 +1,21 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "../validation/TimedCrowdsale.sol";
 
 /**
  * @title FinalizableCrowdsale
- * @dev Extension of Crowdsale with a one-off finalization action, where one
+ * @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.0;
+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,20 +1,21 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "./FinalizableCrowdsale.sol";
 import "../../payment/escrow/RefundEscrow.sol";
 
 /**
  * @title RefundableCrowdsale
- * @dev Extension of Crowdsale contract that adds a funding goal, and the possibility of users getting a refund if goal
- * is not met.
+ * @dev Extension of FinalizableCrowdsale contract that adds a funding goal, and the possibility of users
+ * getting a refund if goal is not met.
  *
  * Deprecated, use RefundablePostDeliveryCrowdsale instead. Note that if you allow tokens to be traded before the goal
  * is met, then an attack is possible in which the attacker purchases tokens from the crowdsale and when they sees that
  * 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.0;
+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.0;
+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.0;
+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.0;
+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;
@@ -28,7 +31,7 @@ contract IncreasingPriceCrowdsale is TimedCrowdsale {
     }
 
     /**
-     * The base rate function is overridden to revert, since this crowdsale doens't use it, and
+     * The base rate function is overridden to revert, since this crowdsale doesn't use it, and
      * all calls to it are a mistake.
      */
     function rate() public view returns (uint256) {
@@ -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.0;
+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.0;
+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,4 +1,6 @@
-pragma solidity ^0.5.0;
+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.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../math/SafeMath.sol";
 import "../Crowdsale.sol";
 
@@ -7,12 +8,19 @@ 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;
     uint256 private _closingTime;
 
+    /**
+     * Event for crowdsale extending
+     * @param newClosingTime new closing time
+     * @param prevClosingTime old closing time
+     */
+    event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
+
     /**
      * @dev Reverts if not in crowdsale time range.
      */
@@ -26,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);
@@ -66,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
@@ -74,4 +88,18 @@ contract TimedCrowdsale is Crowdsale {
     function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
         super._preValidatePurchase(beneficiary, weiAmount);
     }
+
+    /**
+     * @dev Extend crowdsale
+     * @param newClosingTime Crowdsale closing time
+     */
+    function _extendTime(uint256 newClosingTime) internal {
+        require(!hasClosed());
+        require(newClosingTime > _closingTime);
+
+        emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
+        _closingTime = newClosingTime;
+    }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/validation/WhitelistCrowdsale.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 import "../Crowdsale.sol";
 import "../../access/roles/WhitelistedRole.sol";
 
@@ -7,15 +7,23 @@ 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.
-    * @param _beneficiary Token beneficiary
-    * @param _weiAmount Amount of wei contributed
-    */
+     * @dev Extend parent behavior requiring beneficiary to be whitelisted. Note that no
+     * restriction is imposed on the account sending the transaction.
+     * @param _beneficiary Token beneficiary
+     * @param _weiAmount Amount of wei contributed
+     */
     function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view {
         require(isWhitelisted(_beneficiary));
         super._preValidatePurchase(_beneficiary, _weiAmount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/cryptography/ECDSA.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title Elliptic curve signature operations
@@ -14,16 +14,16 @@ library ECDSA {
      * @param signature bytes signature, the signature is generated using web3.eth.sign()
      */
     function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
-        bytes32 r;
-        bytes32 s;
-        uint8 v;
-
         // Check the signature length
         if (signature.length != 65) {
             return (address(0));
         }
 
         // Divide the signature in r, s and v variables
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+
         // ecrecover takes the signature parameters, and the only way to get them
         // currently is to use assembly.
         // solhint-disable-next-line no-inline-assembly
@@ -33,17 +33,25 @@ library ECDSA {
             v := byte(0, mload(add(signature, 0x60)))
         }
 
-        // Version of signature should be 27 or 28, but 0 and 1 are also possible versions
-        if (v < 27) {
-            v += 27;
+        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
+        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
+        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
+        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
+        //
+        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
+        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
+        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
+        // these malleable signatures as well.
+        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
+            return address(0);
         }
 
-        // If the version is correct return the signer address
         if (v != 27 && v != 28) {
-            return (address(0));
-        } else {
-            return ecrecover(hash, v, r, s);
+            return address(0);
         }
+
+        // If the signature is valid (and not malleable), return the signer address
+        return ecrecover(hash, v, r, s);
     }
 
     /**

contracts/cryptography/MerkleProof.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title MerkleProof

contracts/drafts/Counter.sol

@@ -1,24 +0,0 @@
-pragma solidity ^0.5.0;
-
-/**
- * @title Counter
- * @author Matt Condon (@shrugs)
- * @dev Provides an incrementing uint256 id acquired by the `Counter#next` getter.
- * Use this for issuing ERC721 ids or keeping track of request ids, anything you want, really.
- *
- * Include with `using Counter for Counter.Counter;`
- * @notice Does not allow an Id of 0, which is popularly used to signify a null state in solidity.
- * Does not protect from overflows, but if you have 2^256 ids, you have other problems.
- * (But actually, it's generally impossible to increment a counter this many times, energy wise
- * so it's not something you have to worry about.)
- */
-library Counter {
-    struct Counter {
-        uint256 current; // default: 0
-    }
-
-    function next(Counter storage index) internal returns (uint256) {
-        index.current += 1;
-        return index.current;
-    }
-}

contracts/drafts/Counters.sol

@@ -0,0 +1,37 @@
+pragma solidity ^0.5.2;
+
+import "../math/SafeMath.sol";
+
+/**
+ * @title Counters
+ * @author Matt Condon (@shrugs)
+ * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
+ * of elements in a mapping, issuing ERC721 ids, or counting request ids
+ *
+ * Include with `using Counters for Counters.Counter;`
+ * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the SafeMath
+ * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
+ * directly accessed.
+ */
+library Counters {
+    using SafeMath for uint256;
+
+    struct Counter {
+        // This variable should never be directly accessed by users of the library: interactions must be restricted to
+        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
+        // this feature: see https://github.com/ethereum/solidity/issues/4637
+        uint256 _value; // default: 0
+    }
+
+    function current(Counter storage counter) internal view returns (uint256) {
+        return counter._value;
+    }
+
+    function increment(Counter storage counter) internal {
+        counter._value += 1;
+    }
+
+    function decrement(Counter storage counter) internal {
+        counter._value = counter._value.sub(1);
+    }
+}

contracts/drafts/ERC1046/ERC20Metadata.sol

@@ -1,5 +1,6 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../../token/ERC20/IERC20.sol";
 
 /**
@@ -7,18 +8,20 @@ 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 ERC20TokenMetadata is IERC20 {
-    function tokenURI() external view returns (string memory);
-}
-
-contract ERC20WithMetadata is ERC20TokenMetadata {
+contract ERC20Metadata is Initializable {
     string private _tokenURI;
 
-    constructor (string memory tokenURI) public {
-        _tokenURI = tokenURI;
+    function initialize(string memory tokenURI_) public {
+        _setTokenURI(tokenURI_);
     }
 
     function tokenURI() external view returns (string memory) {
         return _tokenURI;
     }
+
+    function _setTokenURI(string memory tokenURI_) internal {
+        _tokenURI = tokenURI_;
+    }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC20Migrator.sol

@@ -1,5 +1,6 @@
-pragma solidity ^0.5.0;
+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";
@@ -17,13 +18,13 @@ import "../math/Math.sol";
  * OpenZeppelin's ERC20Mintable, but the only functions that are needed are
  * `isMinter(address)` and `mint(address, amount)`. The migrator will check
  * that it is a minter for the token.
- * The balance from the legacy token will be transfered to the migrator, as it
+ * The balance from the legacy token will be transferred to the migrator, as it
  * 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;
     }
@@ -65,14 +66,14 @@ contract ERC20Migrator {
     /**
      * @dev Begins the migration by setting which is the new token that will be
      * minted. This contract must be a minter for the new token.
-     * @param newToken the token that will be minted
+     * @param newToken_ the token that will be minted
      */
-    function beginMigration(ERC20Mintable newToken) public {
+    function beginMigration(ERC20Mintable newToken_) public {
         require(address(_newToken) == address(0));
-        require(address(newToken) != address(0));
-        require(newToken.isMinter(address(this)));
+        require(address(newToken_) != address(0));
+        require(newToken_.isMinter(address(this)));
 
-        _newToken = newToken;
+        _newToken = newToken_;
     }
 
     /**
@@ -82,6 +83,7 @@ contract ERC20Migrator {
      * @param amount amount of tokens to be migrated
      */
     function migrate(address account, uint256 amount) public {
+        require(address(_newToken) != address(0));
         _legacyToken.safeTransferFrom(account, address(this), amount);
         _newToken.mint(account, amount);
     }
@@ -97,4 +99,6 @@ contract ERC20Migrator {
         uint256 amount = Math.min(balance, allowance);
         migrate(account, amount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC20Snapshot.sol

@@ -0,0 +1,142 @@
+pragma solidity ^0.5.2;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "../math/SafeMath.sol";
+import "../utils/Arrays.sol";
+import "../drafts/Counters.sol";
+import "../token/ERC20/ERC20.sol";
+
+/**
+ * @title ERC20 token with snapshots.
+ * @dev Inspired by Jordi Baylina's MiniMeToken to record historical balances:
+ * https://github.com/Giveth/minime/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol
+ * When a snapshot is made, the balances and totalSupply at the time of the snapshot are recorded for later
+ * access.
+ *
+ * To make a snapshot, call the `snapshot` function, which will emit the `Snapshot` event and return a snapshot id.
+ * To get the total supply from a snapshot, call the function `totalSupplyAt` with the snapshot id.
+ * To get the balance of an account from a snapshot, call the `balanceOfAt` function with the snapshot id and the
+ * account address.
+ * @author Validity Labs AG <info@validitylabs.org>
+ */
+contract ERC20Snapshot is Initializable, ERC20 {
+    using SafeMath for uint256;
+    using Arrays for uint256[];
+    using Counters for Counters.Counter;
+
+    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
+    // Snapshot struct, but that would impede usage of functions that work on an array.
+    struct Snapshots {
+        uint256[] ids;
+        uint256[] values;
+    }
+
+    mapping (address => Snapshots) private _accountBalanceSnapshots;
+    Snapshots private _totalSupplySnaphots;
+
+    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
+    Counters.Counter private _currentSnapshotId;
+
+    event Snapshot(uint256 id);
+
+    // Creates a new snapshot id. Balances are only stored in snapshots on demand: unless a snapshot was taken, a
+    // balance change will not be recorded. This means the extra added cost of storing snapshotted balances is only paid
+    // when required, but is also flexible enough that it allows for e.g. daily snapshots.
+    function snapshot() public returns (uint256) {
+        _currentSnapshotId.increment();
+
+        uint256 currentId = _currentSnapshotId.current();
+        emit Snapshot(currentId);
+        return currentId;
+    }
+
+    function balanceOfAt(address account, uint256 snapshotId) public view returns (uint256) {
+        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);
+
+        return snapshotted ? value : balanceOf(account);
+    }
+
+    function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
+        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnaphots);
+
+        return snapshotted ? value : totalSupply();
+    }
+
+    // _transfer, _mint and _burn are the only functions where the balances are modified, so it is there that the
+    // snapshots are updated. Note that the update happens _before_ the balance change, with the pre-modified value.
+    // The same is true for the total supply and _mint and _burn.
+    function _transfer(address from, address to, uint256 value) internal {
+        _updateAccountSnapshot(from);
+        _updateAccountSnapshot(to);
+
+        super._transfer(from, to, value);
+    }
+
+    function _mint(address account, uint256 value) internal {
+        _updateAccountSnapshot(account);
+        _updateTotalSupplySnapshot();
+
+        super._mint(account, value);
+    }
+
+    function _burn(address account, uint256 value) internal {
+        _updateAccountSnapshot(account);
+        _updateTotalSupplySnapshot();
+
+        super._burn(account, value);
+    }
+
+    // When a valid snapshot is queried, there are three possibilities:
+    //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
+    //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
+    //  to this id is the current one.
+    //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
+    //  requested id, and its value is the one to return.
+    //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
+    //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
+    //  larger than the requested one.
+    //
+    // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
+    // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
+    // exactly this.
+    function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
+        private view returns (bool, uint256)
+    {
+        require(snapshotId > 0);
+        require(snapshotId <= _currentSnapshotId.current());
+
+        uint256 index = snapshots.ids.findUpperBound(snapshotId);
+
+        if (index == snapshots.ids.length) {
+            return (false, 0);
+        } else {
+            return (true, snapshots.values[index]);
+        }
+    }
+
+    function _updateAccountSnapshot(address account) private {
+        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
+    }
+
+    function _updateTotalSupplySnapshot() private {
+        _updateSnapshot(_totalSupplySnaphots, totalSupply());
+    }
+
+    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
+        uint256 currentId = _currentSnapshotId.current();
+        if (_lastSnapshotId(snapshots.ids) < currentId) {
+            snapshots.ids.push(currentId);
+            snapshots.values.push(currentValue);
+        }
+    }
+
+    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
+        if (ids.length == 0) {
+            return 0;
+        } else {
+            return ids[ids.length - 1];
+        }
+    }
+
+    uint256[50] private ______gap;
+}

contracts/drafts/SignatureBouncer.sol

@@ -1,5 +1,6 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../access/roles/SignerRole.sol";
 import "../cryptography/ECDSA.sol";
 
@@ -29,12 +30,12 @@ import "../cryptography/ECDSA.sol";
  * @notice A method that uses the `onlyValidSignatureAndData` modifier must make
  * the _signature parameter the "last" parameter. You cannot sign a message that
  * has its own signature in it so the last 128 bytes of msg.data (which
- * represents the length of the _signature data and the _signaature data itself)
+ * represents the length of the _signature data and the _signature data itself)
  * is ignored when validating. Also non fixed sized parameters make constructing
  * 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);
     }
 
     /**
@@ -56,7 +57,7 @@ contract SignatureBouncer is SignerRole {
     }
 
     /**
-     * @dev requires that a valid signature with a specifed method of a signer was provided
+     * @dev requires that a valid signature with a specified method of a signer was provided
      */
     modifier onlyValidSignatureAndMethod(bytes memory signature) {
         require(_isValidSignatureAndMethod(msg.sender, signature));
@@ -64,7 +65,7 @@ contract SignatureBouncer is SignerRole {
     }
 
     /**
-     * @dev requires that a valid signature with a specifed method and params of a signer was provided
+     * @dev requires that a valid signature with a specified method and params of a signer was provided
      */
     modifier onlyValidSignatureAndData(bytes memory signature) {
         require(_isValidSignatureAndData(msg.sender, signature));
@@ -72,7 +73,7 @@ contract SignatureBouncer is SignerRole {
     }
 
     /**
-     * @dev is the signature of `this + sender` from a signer?
+     * @dev is the signature of `this + account` from a signer?
      * @return bool
      */
     function _isValidSignature(address account, bytes memory signature) internal view returns (bool) {
@@ -80,7 +81,7 @@ contract SignatureBouncer is SignerRole {
     }
 
     /**
-     * @dev is the signature of `this + sender + methodId` from a signer?
+     * @dev is the signature of `this + account + methodId` from a signer?
      * @return bool
      */
     function _isValidSignatureAndMethod(address account, bytes memory signature) internal view returns (bool) {
@@ -92,10 +93,10 @@ contract SignatureBouncer is SignerRole {
     }
 
     /**
-        * @dev is the signature of `this + sender + methodId + params(s)` from a signer?
-        * @notice the signature parameter of the method being validated must be the "last" parameter
-        * @return bool
-        */
+     * @dev is the signature of `this + account + methodId + params(s)` from a signer?
+     * @notice the signature parameter of the method being validated must be the "last" parameter
+     * @return bool
+     */
     function _isValidSignatureAndData(address account, bytes memory signature) internal view returns (bool) {
         require(msg.data.length > _SIGNATURE_SIZE);
 
@@ -117,4 +118,6 @@ contract SignatureBouncer is SignerRole {
 
         return signer != address(0) && isSigner(signer);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/SignedSafeMath.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title SignedSafeMath
@@ -8,8 +8,8 @@ library SignedSafeMath {
     int256 constant private INT256_MIN = -2**255;
 
     /**
-    * @dev Multiplies two signed integers, reverts on overflow.
-    */
+     * @dev Multiplies two signed integers, reverts on overflow.
+     */
     function mul(int256 a, int256 b) internal pure returns (int256) {
         // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
         // benefit is lost if 'b' is also tested.
@@ -27,8 +27,8 @@ library SignedSafeMath {
     }
 
     /**
-    * @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.
-    */
+     * @dev Integer division of two signed integers truncating the quotient, reverts on division by zero.
+     */
     function div(int256 a, int256 b) internal pure returns (int256) {
         require(b != 0); // Solidity only automatically asserts when dividing by 0
         require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
@@ -39,8 +39,8 @@ library SignedSafeMath {
     }
 
     /**
-    * @dev Subtracts two signed integers, reverts on overflow.
-    */
+     * @dev Subtracts two signed integers, reverts on overflow.
+     */
     function sub(int256 a, int256 b) internal pure returns (int256) {
         int256 c = a - b;
         require((b >= 0 && c <= a) || (b < 0 && c > a));
@@ -49,8 +49,8 @@ library SignedSafeMath {
     }
 
     /**
-    * @dev Adds two signed integers, reverts on overflow.
-    */
+     * @dev Adds two signed integers, reverts on overflow.
+     */
     function add(int256 a, int256 b) internal pure returns (int256) {
         int256 c = a + b;
         require((b >= 0 && c >= a) || (b < 0 && c < a));

contracts/drafts/TokenVesting.sol

@@ -1,5 +1,6 @@
-pragma solidity ^0.5.0;
+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,11 +11,11 @@ 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 cliff
-    // period of a year and a duration of four years, are safe to use.
+    // it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
+    // cliff period of a year and a duration of four years, are safe to use.
     // solhint-disable not-rely-on-time
 
     using SafeMath for uint256;
@@ -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.0;
+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.0;
+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.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "./IERC165.sol";
 
 /**
@@ -7,9 +8,9 @@ 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 ===
      *     bytes4(keccak256('supportsInterface(bytes4)'))
      */
@@ -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/introspection/ERC165Checker.sol

@@ -1,16 +1,16 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title ERC165Checker
  * @dev Use `using ERC165Checker for address`; to include this library
- * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
+ * https://eips.ethereum.org/EIPS/eip-165
  */
 library ERC165Checker {
     // As per the EIP-165 spec, no interface should ever match 0xffffffff
     bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
 
     bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
-    /**
+    /*
      * 0x01ffc9a7 ===
      *     bytes4(keccak256('supportsInterface(bytes4)'))
      */
@@ -109,15 +109,15 @@ library ERC165Checker {
             mstore(output, 0x0)
 
             success := staticcall(
-                30000,                                 // 30k gas
-                account,                            // To addr
+                30000,                   // 30k gas
+                account,                 // To addr
                 encodedParams_data,
                 encodedParams_size,
                 output,
-                0x20                                     // Outputs are 32 bytes long
+                0x20                     // Outputs are 32 bytes long
             )
 
-            result := mload(output)    // Load the result
+            result := mload(output)      // Load the result
         }
     }
 }

contracts/introspection/IERC165.sol

@@ -1,8 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title IERC165
- * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
+ * @dev https://eips.ethereum.org/EIPS/eip-165
  */
 interface IERC165 {
     /**

contracts/lifecycle/Pausable.sol

@@ -1,18 +1,21 @@
-pragma solidity ^0.5.0;
+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/math/Math.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title Math
@@ -6,24 +6,24 @@ pragma solidity ^0.5.0;
  */
 library Math {
     /**
-    * @dev Returns the largest of two numbers.
-    */
+     * @dev Returns the largest of two numbers.
+     */
     function max(uint256 a, uint256 b) internal pure returns (uint256) {
         return a >= b ? a : b;
     }
 
     /**
-    * @dev Returns the smallest of two numbers.
-    */
+     * @dev Returns the smallest of two numbers.
+     */
     function min(uint256 a, uint256 b) internal pure returns (uint256) {
         return a < b ? a : b;
     }
 
     /**
-    * @dev Calculates the average of two numbers. Since these are integers,
-    * averages of an even and odd number cannot be represented, and will be
-    * rounded down.
-    */
+     * @dev Calculates the average of two numbers. Since these are integers,
+     * averages of an even and odd number cannot be represented, and will be
+     * rounded down.
+     */
     function average(uint256 a, uint256 b) internal pure returns (uint256) {
         // (a + b) / 2 can overflow, so we distribute
         return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);

contracts/math/SafeMath.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title SafeMath
@@ -6,8 +6,8 @@ pragma solidity ^0.5.0;
  */
 library SafeMath {
     /**
-    * @dev Multiplies two unsigned integers, reverts on overflow.
-    */
+     * @dev Multiplies two unsigned integers, reverts on overflow.
+     */
     function mul(uint256 a, uint256 b) internal pure returns (uint256) {
         // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
         // benefit is lost if 'b' is also tested.
@@ -23,8 +23,8 @@ library SafeMath {
     }
 
     /**
-    * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
-    */
+     * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
+     */
     function div(uint256 a, uint256 b) internal pure returns (uint256) {
         // Solidity only automatically asserts when dividing by 0
         require(b > 0);
@@ -35,8 +35,8 @@ library SafeMath {
     }
 
     /**
-    * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
-    */
+     * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
+     */
     function sub(uint256 a, uint256 b) internal pure returns (uint256) {
         require(b <= a);
         uint256 c = a - b;
@@ -45,8 +45,8 @@ library SafeMath {
     }
 
     /**
-    * @dev Adds two unsigned integers, reverts on overflow.
-    */
+     * @dev Adds two unsigned integers, reverts on overflow.
+     */
     function add(uint256 a, uint256 b) internal pure returns (uint256) {
         uint256 c = a + b;
         require(c >= a);
@@ -55,9 +55,9 @@ library SafeMath {
     }
 
     /**
-    * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
-    * reverts when dividing by zero.
-    */
+     * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
+     * reverts when dividing by zero.
+     */
     function mod(uint256 a, uint256 b) internal pure returns (uint256) {
         require(b != 0);
         return a % b;

contracts/mocks/Acknowledger.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 contract Acknowledger {
     event AcknowledgeFoo(uint256 a);

contracts/mocks/AddressImpl.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../utils/Address.sol";
 

contracts/mocks/AllowanceCrowdsaleImpl.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/emission/AllowanceCrowdsale.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/ArraysImpl.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../utils/Arrays.sol";
 

contracts/mocks/CappedCrowdsaleImpl.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/validation/CappedCrowdsale.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

@@ -1,8 +1,12 @@
-pragma solidity ^0.5.0;
+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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../payment/escrow/ConditionalEscrow.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/CounterImpl.sol

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

contracts/mocks/CountersImpl.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.5.2;
+
+import "../drafts/Counters.sol";
+
+contract CountersImpl {
+    using Counters for Counters.Counter;
+
+    Counters.Counter private _counter;
+
+    function current() public view returns (uint256) {
+        return _counter.current();
+    }
+
+    function increment() public {
+        _counter.increment();
+    }
+
+    function decrement() public {
+        _counter.decrement();
+    }
+}

contracts/mocks/CrowdsaleMock.sol

@@ -1,9 +1,9 @@
-pragma solidity ^0.5.0;
+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/ECDSAMock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../cryptography/ECDSA.sol";
 

contracts/mocks/ERC165/ERC165InterfacesSupported.sol

@@ -1,9 +1,10 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../../introspection/IERC165.sol";
 
 /**
- * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-214.md#specification
+ * https://eips.ethereum.org/EIPS/eip-214#specification
+ * From the specification:
  * > Any attempts to make state-changing operations inside an execution instance with STATIC set to true will instead
  * throw an exception.
  * > These operations include [...], LOG0, LOG1, LOG2, [...]
@@ -13,7 +14,7 @@ import "../../introspection/IERC165.sol";
  */
 contract SupportsInterfaceWithLookupMock is IERC165 {
     bytes4 public constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
-    /**
+    /*
      * 0x01ffc9a7 ===
      *     bytes4(keccak256('supportsInterface(bytes4)'))
      */

contracts/mocks/ERC165/ERC165NotSupported.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 contract ERC165NotSupported {
     // solhint-disable-previous-line no-empty-blocks

contracts/mocks/ERC165CheckerMock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../introspection/ERC165Checker.sol";
 

contracts/mocks/ERC165Mock.sol

@@ -1,8 +1,12 @@
-pragma solidity ^0.5.0;
+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

@@ -1,9 +1,9 @@
-pragma solidity ^0.5.0;
+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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/ERC20.sol";
 import "../token/ERC20/ERC20Detailed.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

@@ -0,0 +1,14 @@
+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.initialize(tokenURI);
+    }
+
+    function setTokenURI(string memory tokenURI) public {
+        _setTokenURI(tokenURI);
+    }
+}

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

@@ -1,8 +1,10 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 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/ERC20Mock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/ERC20.sol";
 
@@ -19,4 +19,8 @@ contract ERC20Mock is ERC20 {
     function burnFrom(address account, uint256 amount) public {
         _burnFrom(account, amount);
     }
+
+    function approveInternal(address owner, address spender, uint256 value) public {
+        _approve(owner, spender, value);
+    }
 }

contracts/mocks/ERC20PausableMock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/ERC20Pausable.sol";
 import "./PauserRoleMock.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/ERC20SnapshotMock.sol

@@ -0,0 +1,18 @@
+pragma solidity ^0.5.2;
+
+import "../drafts/ERC20Snapshot.sol";
+
+
+contract ERC20SnapshotMock is ERC20Snapshot {
+    constructor(address initialAccount, uint256 initialBalance) public {
+        _mint(initialAccount, initialBalance);
+    }
+
+    function mint(address account, uint256 amount) public {
+        _mint(account, amount);
+    }
+
+    function burn(address account, uint256 amount) public {
+        _burn(account, amount);
+    }
+}

contracts/mocks/ERC20WithMetadataMock.sol

@@ -1,10 +0,0 @@
-pragma solidity ^0.5.0;
-
-import "../token/ERC20/ERC20.sol";
-import "../drafts/ERC1046/TokenMetadata.sol";
-
-contract ERC20WithMetadataMock is ERC20, ERC20WithMetadata {
-    constructor (string memory tokenURI) public ERC20WithMetadata(tokenURI) {
-        // solhint-disable-previous-line no-empty-blocks
-    }
-}

contracts/mocks/ERC721FullMock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC721/ERC721Full.sol";
 import "../token/ERC721/ERC721Mintable.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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC721/ERC721Full.sol";
 import "../token/ERC721/ERC721Mintable.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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC721/ERC721.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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC721/ERC721Pausable.sol";
 import "./PauserRoleMock.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/ERC721ReceiverMock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC721/IERC721Receiver.sol";
 

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/EventEmitter.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 contract EventEmitter {
     event Argumentless();

contracts/mocks/Failer.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 contract Failer {
     uint256[] private array;

contracts/mocks/FinalizableCrowdsaleImpl.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/FinalizableCrowdsale.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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../crowdsale/price/IncreasingPriceCrowdsale.sol";
 import "../math/SafeMath.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

@@ -1,11 +1,12 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/IERC20.sol";
 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/MathMock.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../math/Math.sol";
 

contracts/mocks/MerkleProofWrapper.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import { MerkleProof } from "../cryptography/MerkleProof.sol";
 

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

@@ -1,10 +1,10 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 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

@@ -1,8 +1,12 @@
-pragma solidity ^0.5.0;
+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/OwnableInterfaceId.sol

@@ -1,11 +1,11 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../ownership/Ownable.sol";
 
 /**
  * @title Ownable interface id calculator.
  * @dev See the EIP165 specification for more information:
- * https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md#specification
+ * https://eips.ethereum.org/EIPS/eip-165#specification
  */
 contract OwnableInterfaceId {
     function getInterfaceId() public pure returns (bytes4) {

contracts/mocks/OwnableMock.sol

@@ -1,7 +1,9 @@
-pragma solidity ^0.5.0;
+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

@@ -1,10 +1,11 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../lifecycle/Pausable.sol";
 import "./PauserRoleMock.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

@@ -1,8 +1,12 @@
-pragma solidity ^0.5.0;
+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

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../token/ERC20/IERC20.sol";
 import "../crowdsale/distribution/PostDeliveryCrowdsale.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);
     }
 }