v2.2.3

* switch to using Context internally

* add context import

* Add smoke test to make sure enabling GSN support works

* Update test/GSN/ERC721GSNRecipientMock.test.js

Co-Authored-By: Francisco Giordano <frangio.1@gmail.com>

* Upgrade truffle

* add missing awaits

* Revert "Upgrade truffle"

This reverts commit f9b0ba9019.

.circleci/config.yml

@@ -0,0 +1,82 @@
+version: 2
+# 2.1 does not yet support local run
+# unless with workaround. For simplicity just use it.
+# https://github.com/CircleCI-Public/circleci-cli/issues/79
+
+aliases:
+  - &defaults
+    docker:
+      - image: circleci/node:8
+
+  - &npm_install_if_necessary
+    run:
+      name: Install npm dependencies
+      command: |
+        if [ ! -d node_modules ]; then
+          npm ci
+        fi
+
+  - &cache_key_node_modules
+    key: v1-node_modules-{{ checksum "package-lock.json" }}
+
+jobs:
+  dependencies:
+    <<: *defaults
+    steps:
+      - checkout
+      - restore_cache:
+          <<: *cache_key_node_modules
+      - *npm_install_if_necessary
+      - save_cache:
+          paths:
+            - node_modules
+          <<: *cache_key_node_modules
+
+  lint:
+    <<: *defaults
+    steps:
+      - checkout
+      - restore_cache:
+          <<: *cache_key_node_modules
+      - *npm_install_if_necessary
+      - run:
+          name: Linter
+          command: npm run lint
+  test:
+    <<: *defaults
+    steps:
+      - checkout
+      - restore_cache:
+          <<: *cache_key_node_modules
+      - *npm_install_if_necessary
+      - run:
+          name: Unit tests
+          command: npm run test
+  coverage:
+    docker:
+      - image: circleci/node:8
+    steps:
+      - checkout
+      - restore_cache:
+          <<: *cache_key_node_modules
+      - *npm_install_if_necessary
+      - run:
+          name: Unit tests with coverage report
+          command: npm run coverage
+
+      # TODO(xinbenlv, #1839): run SOLC_NIGHTLY to be run but allow it to fail.
+
+workflows:
+  version: 2
+  everything:
+    jobs:
+      - dependencies
+      - lint:
+          requires:
+            - dependencies
+      - test:
+          requires:
+            - dependencies
+      - coverage:
+          requires:
+            - dependencies

.editorconfig

@@ -6,7 +6,12 @@ root = true
 [*]
 charset = utf-8
 end_of_line = lf
-indent_size = 2
 indent_style = space
 insert_final_newline = true
 trim_trailing_whitespace = true
+
+[*.sol]
+indent_size = 4
+
+[*.js]
+indent_size = 2

.github/ISSUE_TEMPLATE/bug_report.md

@@ -6,7 +6,7 @@ about: Report a bug in OpenZeppelin
 
 <!-- Briefly describe the issue you're experiencing. Tell us what you were trying to do and what happened instead. -->
 
-<!-- Remember, this is not a place to ask for help debugging code. For that, we welcome you in the Zeppelin Forum: https://forum.zeppelin.solutions/. -->
+<!-- Remember, this is not a place to ask for help debugging code. For that, we welcome you in the OpenZeppelin Slack channel: https://slack.openzeppelin.org/. -->
 
 **💻 Environment**
 

.github/stale.yml

@@ -1,66 +0,0 @@
-# Configuration for probot-stale - https://github.com/probot/stale
-
-# Number of days of inactivity before an Issue or Pull Request becomes stale
-daysUntilStale: 15
-
-# Number of days of inactivity before an Issue or Pull Request with the stale label is closed.
-# Set to false to disable. If disabled, issues still need to be closed manually, but will remain marked as stale.
-daysUntilClose: 15
-
-# Issues or Pull Requests with these labels will never be considered stale. Set to `[]` to disable
-exemptLabels:
-  - on hold
-
-# Set to true to ignore issues in a project (defaults to false)
-exemptProjects: false
-
-# Set to true to ignore issues in a milestone (defaults to false)
-exemptMilestones: false
-
-# Set to true to ignore issues with an assignee (defaults to false)
-exemptAssignees: false
-
-# Label to use when marking as stale
-staleLabel: stale
-
-# Comment to post when marking as stale. Set to `false` to disable
-markComment: >
-  Hi all!
-
-  This Pull Request has not had any recent activity, is it still relevant? If so, what is blocking it?
-  Is there anything we can do to help move it forward?
-
-  Thanks!
-
-
-# Comment to post when removing the stale label.
-# unmarkComment: >
-#   Your comment here.
-
-# Comment to post when closing a stale Issue or Pull Request.
-closeComment: >
-  Hi folks!
-
-  This Pull Request is being closed as there was no response to the previous prompt.
-  However, please leave a comment whenever you're ready to resume, so it can be reopened.
-
-  Thanks again!
-
-
-# Limit the number of actions per hour, from 1-30. Default is 30
-limitPerRun: 30
-
-# Limit to only `issues` or `pulls`
-only: pulls
-
-# Optionally, specify configuration settings that are specific to just 'issues' or 'pulls':
-# pulls:
-#   daysUntilStale: 30
-#   markComment: >
-#     This pull request has been automatically marked as stale because it has not had
-#     recent activity. It will be closed if no further activity occurs. Thank you
-#     for your contributions.
-
-# issues:
-#   exemptLabels:
-#     - confirmed

.gitignore

@@ -38,9 +38,7 @@ build/
 # truffle
 .node-xmlhttprequest-*
 
+.openzeppelin/.session
+
 # IntelliJ IDE
 .idea
-
-# docsite artifacts
-docsite-build
-docs/api

.openzeppelin/kovan.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "StandaloneERC721": {
+      "address": "0xb8cBf1CC110c42C15CEf3CA0982b812a82d99613",
+      "constructorCode": "60806040526139f3806100136000396000f3fe",
+      "bodyBytecodeHash": "33aac4411967c3463cdac9bb7d6d491c9bd9f8338aeb53d8ebe0cf054abb2508",
+      "localBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "deployedBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "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": 3662,
+              "type": "t_uint256",
+              "src": "1021:14:30"
+            }
+          ]
+        },
+        "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5232,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5276,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11717,
+          "type": "t_mapping<t_address>",
+          "src": "886:48:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11721,
+          "type": "t_mapping<t_address>",
+          "src": "990:52:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11725,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1100:63:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11731,
+          "type": "t_mapping<t_bool>",
+          "src": "1218:73:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12258,
+          "type": "t_array:50<t_uint256>",
+          "src": "11985:29:136"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12316,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "502:50:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12320,
+          "type": "t_mapping<t_uint256>",
+          "src": "622:53:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12323,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "736:28:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12327,
+          "type": "t_mapping<t_uint256>",
+          "src": "835:51:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12656,
+          "type": "t_array:50<t_uint256>",
+          "src": "8858:29:138"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12726,
+          "type": "t_string",
+          "src": "323:20:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12728,
+          "type": "t_string",
+          "src": "370:22:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12732,
+          "type": "t_mapping<t_string>",
+          "src": "438:45:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12861,
+          "type": "t_array:50<t_uint256>",
+          "src": "2891:29:141"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12931,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:142"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 13076,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:144"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11725,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1100:63:136"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0xaabC7f35AF87B61148cD4047828cC7FC0707D771",
+      "constructorCode": "6080604052612b68806100136000396000f3fe",
+      "bodyBytecodeHash": "47dc17b93316f8df939ac42afd023448ba98f3c8d3f7e4240f118217a4e3020e",
+      "localBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "deployedBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        },
+        "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10854,
+          "type": "t_string",
+          "src": "397:20:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10856,
+          "type": "t_string",
+          "src": "423:22:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10858,
+          "type": "t_uint8",
+          "src": "451:23:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10910,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:129"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10355,
+          "type": "t_mapping<t_uint256>",
+          "src": "809:46:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 10361,
+          "type": "t_mapping<t_uint256>",
+          "src": "862:69:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10363,
+          "type": "t_uint256",
+          "src": "938:28:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10728,
+          "type": "t_array:50<t_uint256>",
+          "src": "7822:29:126"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10959,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:130"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 11082,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:131"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 10361,
+              "type": "t_mapping<t_uint256>",
+              "src": "862:69:126"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            }
+          }
+        ]
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0xfa6124374Dc57302252Ad8A6cd3D7879e0B4fCfa",
+      "constructorCode": "6080604052610bf2806100136000396000f3fe",
+      "bodyBytecodeHash": "f80b1634ecca81b01cd4155b3ceba5e85979d18489c685ce4bc0f3e16e50ed3d",
+      "localBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "deployedBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9654,
+          "type": "t_uint256",
+          "src": "593:28:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9656,
+          "type": "t_uint256",
+          "src": "627:30:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9660,
+          "type": "t_mapping<t_uint256>",
+          "src": "664:43:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9664,
+          "type": "t_mapping<t_uint256>",
+          "src": "713:45:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9667,
+          "type": "t_array:dyn<t_address>",
+          "src": "764:25:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9913,
+          "type": "t_array:50<t_uint256>",
+          "src": "3291:29:121"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "TokenVesting": {
+      "address": "0x915BBFBbA9C7090cd9622dE0157aE58EC4E3E802",
+      "constructorCode": "60806040526114e7806100136000396000f3fe",
+      "bodyBytecodeHash": "c304cafc8a928423a24501d5e106dca14630e603c16dca8d9cc17569984beaa2",
+      "localBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "deployedBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9431,
+          "type": "t_address",
+          "src": "356:22:119"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9542,
+          "type": "t_array:50<t_uint256>",
+          "src": "2318:29:119"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4701,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4703,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4705,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4707,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4709,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4713,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4717,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5059,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0xf5829D56998ccC1405B7eAbCCAC78164AF270D39"
+  },
+  "package": {
+    "address": "0xB6F8F11b166D526932ee04ffe4D25B810f619E34"
+  },
+  "provider": {
+    "address": "0x9c541d23dc741A876766C1acBA86d0Ad41846CD7"
+  },
+  "version": "2.2.3"
+}

.openzeppelin/mainnet.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "PaymentSplitter": {
+      "address": "0xC6C65338632a6E84f7D67C94EAC117571932e95c",
+      "constructorCode": "6080604052610bf2806100136000396000f3fe",
+      "bodyBytecodeHash": "f80b1634ecca81b01cd4155b3ceba5e85979d18489c685ce4bc0f3e16e50ed3d",
+      "localBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "deployedBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9654,
+          "type": "t_uint256",
+          "src": "593:28:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9656,
+          "type": "t_uint256",
+          "src": "627:30:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9660,
+          "type": "t_mapping<t_uint256>",
+          "src": "664:43:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9664,
+          "type": "t_mapping<t_uint256>",
+          "src": "713:45:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9667,
+          "type": "t_array:dyn<t_address>",
+          "src": "764:25:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9913,
+          "type": "t_array:50<t_uint256>",
+          "src": "3291:29:121"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0xB7F08c44086Baa3c8e74b68E2817B5ae633770BF",
+      "constructorCode": "6080604052612b68806100136000396000f3fe",
+      "bodyBytecodeHash": "47dc17b93316f8df939ac42afd023448ba98f3c8d3f7e4240f118217a4e3020e",
+      "localBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "deployedBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        },
+        "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10854,
+          "type": "t_string",
+          "src": "397:20:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10856,
+          "type": "t_string",
+          "src": "423:22:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10858,
+          "type": "t_uint8",
+          "src": "451:23:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10910,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:129"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10355,
+          "type": "t_mapping<t_uint256>",
+          "src": "809:46:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 10361,
+          "type": "t_mapping<t_uint256>",
+          "src": "862:69:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10363,
+          "type": "t_uint256",
+          "src": "938:28:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10728,
+          "type": "t_array:50<t_uint256>",
+          "src": "7822:29:126"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10959,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:130"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 11082,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:131"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 10361,
+              "type": "t_mapping<t_uint256>",
+              "src": "862:69:126"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            }
+          }
+        ]
+      }
+    },
+    "TokenVesting": {
+      "address": "0x6498CB302b94AD841BfeCfB55F56781dCDDA4754",
+      "constructorCode": "60806040526114e7806100136000396000f3fe",
+      "bodyBytecodeHash": "c304cafc8a928423a24501d5e106dca14630e603c16dca8d9cc17569984beaa2",
+      "localBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "deployedBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9431,
+          "type": "t_address",
+          "src": "356:22:119"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9542,
+          "type": "t_array:50<t_uint256>",
+          "src": "2318:29:119"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4701,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4703,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4705,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4707,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4709,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4713,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4717,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5059,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0x856d154656930060f9999848690D1c06c7C5eFD1",
+      "constructorCode": "60806040526139f3806100136000396000f3fe",
+      "bodyBytecodeHash": "33aac4411967c3463cdac9bb7d6d491c9bd9f8338aeb53d8ebe0cf054abb2508",
+      "localBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "deployedBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "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": 3662,
+              "type": "t_uint256",
+              "src": "1021:14:30"
+            }
+          ]
+        },
+        "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5232,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5276,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11717,
+          "type": "t_mapping<t_address>",
+          "src": "886:48:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11721,
+          "type": "t_mapping<t_address>",
+          "src": "990:52:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11725,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1100:63:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11731,
+          "type": "t_mapping<t_bool>",
+          "src": "1218:73:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12258,
+          "type": "t_array:50<t_uint256>",
+          "src": "11985:29:136"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12316,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "502:50:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12320,
+          "type": "t_mapping<t_uint256>",
+          "src": "622:53:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12323,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "736:28:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12327,
+          "type": "t_mapping<t_uint256>",
+          "src": "835:51:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12656,
+          "type": "t_array:50<t_uint256>",
+          "src": "8858:29:138"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12726,
+          "type": "t_string",
+          "src": "323:20:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12728,
+          "type": "t_string",
+          "src": "370:22:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12732,
+          "type": "t_mapping<t_string>",
+          "src": "438:45:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12861,
+          "type": "t_array:50<t_uint256>",
+          "src": "2891:29:141"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12931,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:142"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 13076,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:144"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11725,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1100:63:136"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x2Ba1a8C7352a5B5Ea3ea3408F89e1bA7920d36CE"
+  },
+  "package": {
+    "address": "0x778dddF23Ec1B5Cb18394c6C110480CaaDB3B0f6"
+  },
+  "provider": {
+    "address": "0xfeEdcb2Bd3b5EAA52aA64063ce16ECc4987da658"
+  },
+  "version": "2.2.3"
+}

.openzeppelin/project.json

@@ -0,0 +1,19 @@
+{
+  "manifestVersion": "2.2",
+  "name": "@openzeppelin/contracts-ethereum-package",
+  "publish": true,
+  "version": "2.2.3",
+  "contracts": {
+    "StandaloneERC20": "StandaloneERC20",
+    "StandaloneERC721": "StandaloneERC721",
+    "TokenVesting": "TokenVesting",
+    "PaymentSplitter": "PaymentSplitter"
+  },
+  "dependencies": {},
+  "compiler": {
+    "manager": "truffle",
+    "compilerSettings": {
+      "optimizer": {}
+    }
+  }
+}

.openzeppelin/rinkeby.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "StandaloneERC20": {
+      "address": "0x73fa66eA7944a51453e78970dC84634D91e4848c",
+      "constructorCode": "6080604052612b68806100136000396000f3fe",
+      "bodyBytecodeHash": "47dc17b93316f8df939ac42afd023448ba98f3c8d3f7e4240f118217a4e3020e",
+      "localBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "deployedBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        },
+        "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10854,
+          "type": "t_string",
+          "src": "397:20:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10856,
+          "type": "t_string",
+          "src": "423:22:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10858,
+          "type": "t_uint8",
+          "src": "451:23:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10910,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:129"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10355,
+          "type": "t_mapping<t_uint256>",
+          "src": "809:46:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 10361,
+          "type": "t_mapping<t_uint256>",
+          "src": "862:69:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10363,
+          "type": "t_uint256",
+          "src": "938:28:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10728,
+          "type": "t_array:50<t_uint256>",
+          "src": "7822:29:126"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10959,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:130"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 11082,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:131"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 10361,
+              "type": "t_mapping<t_uint256>",
+              "src": "862:69:126"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            }
+          }
+        ]
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0xc0b7305Ce44b261332E548CC9E7FD3CAFb798426",
+      "constructorCode": "6080604052610bf2806100136000396000f3fe",
+      "bodyBytecodeHash": "f80b1634ecca81b01cd4155b3ceba5e85979d18489c685ce4bc0f3e16e50ed3d",
+      "localBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "deployedBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9654,
+          "type": "t_uint256",
+          "src": "593:28:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9656,
+          "type": "t_uint256",
+          "src": "627:30:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9660,
+          "type": "t_mapping<t_uint256>",
+          "src": "664:43:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9664,
+          "type": "t_mapping<t_uint256>",
+          "src": "713:45:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9667,
+          "type": "t_array:dyn<t_address>",
+          "src": "764:25:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9913,
+          "type": "t_array:50<t_uint256>",
+          "src": "3291:29:121"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "TokenVesting": {
+      "address": "0x1e06B993696bD78871406BaaE1C473da23830AcC",
+      "constructorCode": "60806040526114e7806100136000396000f3fe",
+      "bodyBytecodeHash": "c304cafc8a928423a24501d5e106dca14630e603c16dca8d9cc17569984beaa2",
+      "localBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "deployedBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9431,
+          "type": "t_address",
+          "src": "356:22:119"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9542,
+          "type": "t_array:50<t_uint256>",
+          "src": "2318:29:119"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4701,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4703,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4705,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4707,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4709,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4713,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4717,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5059,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0x7Fe0a0E67409503Cf795d47E1Db0c77A2220210b",
+      "constructorCode": "60806040526139f3806100136000396000f3fe",
+      "bodyBytecodeHash": "33aac4411967c3463cdac9bb7d6d491c9bd9f8338aeb53d8ebe0cf054abb2508",
+      "localBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "deployedBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "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": 3662,
+              "type": "t_uint256",
+              "src": "1021:14:30"
+            }
+          ]
+        },
+        "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5232,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5276,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11717,
+          "type": "t_mapping<t_address>",
+          "src": "886:48:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11721,
+          "type": "t_mapping<t_address>",
+          "src": "990:52:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11725,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1100:63:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11731,
+          "type": "t_mapping<t_bool>",
+          "src": "1218:73:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12258,
+          "type": "t_array:50<t_uint256>",
+          "src": "11985:29:136"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12316,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "502:50:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12320,
+          "type": "t_mapping<t_uint256>",
+          "src": "622:53:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12323,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "736:28:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12327,
+          "type": "t_mapping<t_uint256>",
+          "src": "835:51:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12656,
+          "type": "t_array:50<t_uint256>",
+          "src": "8858:29:138"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12726,
+          "type": "t_string",
+          "src": "323:20:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12728,
+          "type": "t_string",
+          "src": "370:22:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12732,
+          "type": "t_mapping<t_string>",
+          "src": "438:45:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12861,
+          "type": "t_array:50<t_uint256>",
+          "src": "2891:29:141"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12931,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:142"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 13076,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:144"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11725,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1100:63:136"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x291439E6444dAEc9e47Ae359Aa79FD1811A42679"
+  },
+  "package": {
+    "address": "0xa44bb80b290dE8a465d17B14269dF53CF0B9Bf4f"
+  },
+  "provider": {
+    "address": "0xb3356E12194d3A8a847bA76313a83718d6729eCf"
+  },
+  "version": "2.2.3"
+}

.openzeppelin/ropsten.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "TokenVesting": {
+      "address": "0x87C4eE5Ce946291BCcF4ac3333f44CFfDE26f98a",
+      "constructorCode": "60806040526114e7806100136000396000f3fe",
+      "bodyBytecodeHash": "c304cafc8a928423a24501d5e106dca14630e603c16dca8d9cc17569984beaa2",
+      "localBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "deployedBytecodeHash": "eb377fbbff249e0f05823b8b4312d3caddce2867da947eb7a0ad85800e4db993",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9431,
+          "type": "t_address",
+          "src": "356:22:119"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9542,
+          "type": "t_array:50<t_uint256>",
+          "src": "2318:29:119"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4701,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4703,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4705,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4707,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4709,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4713,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4717,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5059,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0x621DB5C5B8A6CFd829bDAe49D0a2c2e90797Fc38",
+      "constructorCode": "6080604052610bf2806100136000396000f3fe",
+      "bodyBytecodeHash": "f80b1634ecca81b01cd4155b3ceba5e85979d18489c685ce4bc0f3e16e50ed3d",
+      "localBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "deployedBytecodeHash": "4fffe4f76deb208e21319fb0b5446ab2b82b2ec221097e510f0ee982a12717b6",
+      "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9654,
+          "type": "t_uint256",
+          "src": "593:28:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9656,
+          "type": "t_uint256",
+          "src": "627:30:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9660,
+          "type": "t_mapping<t_uint256>",
+          "src": "664:43:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9664,
+          "type": "t_mapping<t_uint256>",
+          "src": "713:45:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9667,
+          "type": "t_array:dyn<t_address>",
+          "src": "764:25:121"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9913,
+          "type": "t_array:50<t_uint256>",
+          "src": "3291:29:121"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0xe491769618D3acFbBdC403841a66FC1023E711C6",
+      "constructorCode": "6080604052612b68806100136000396000f3fe",
+      "bodyBytecodeHash": "47dc17b93316f8df939ac42afd023448ba98f3c8d3f7e4240f118217a4e3020e",
+      "localBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "deployedBytecodeHash": "92d11f5376cafd394027eedcf15b21805f9e8e4293a286b74e8c44620c324b34",
+      "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        },
+        "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": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10854,
+          "type": "t_string",
+          "src": "397:20:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10856,
+          "type": "t_string",
+          "src": "423:22:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10858,
+          "type": "t_uint8",
+          "src": "451:23:129"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10910,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:129"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10355,
+          "type": "t_mapping<t_uint256>",
+          "src": "809:46:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowances",
+          "astId": 10361,
+          "type": "t_mapping<t_uint256>",
+          "src": "862:69:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10363,
+          "type": "t_uint256",
+          "src": "938:28:126"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10728,
+          "type": "t_array:50<t_uint256>",
+          "src": "7822:29:126"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10959,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:130"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 11082,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:131"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 10361,
+              "type": "t_mapping<t_uint256>",
+              "src": "862:69:126"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            }
+          }
+        ]
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0xE77B22d034cF85F2F851516D9BdC2fF2D76471D3",
+      "constructorCode": "60806040526139f3806100136000396000f3fe",
+      "bodyBytecodeHash": "33aac4411967c3463cdac9bb7d6d491c9bd9f8338aeb53d8ebe0cf054abb2508",
+      "localBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "deployedBytecodeHash": "16e6da0afa76f1d342939ec26b9213e99b8b707e52b930005971e9d752fdc54a",
+      "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": 3662,
+              "type": "t_uint256",
+              "src": "1021:14:30"
+            }
+          ]
+        },
+        "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": 1222,
+              "type": "t_mapping<t_bool>",
+              "src": "150:32:8"
+            }
+          ]
+        }
+      },
+      "storage": [
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initialized",
+          "astId": 13536,
+          "type": "t_bool",
+          "src": "757:24:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13538,
+          "type": "t_bool",
+          "src": "876:25:154"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13594,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:154"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5232,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5276,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11717,
+          "type": "t_mapping<t_address>",
+          "src": "886:48:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11721,
+          "type": "t_mapping<t_address>",
+          "src": "990:52:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11725,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1100:63:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11731,
+          "type": "t_mapping<t_bool>",
+          "src": "1218:73:136"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12258,
+          "type": "t_array:50<t_uint256>",
+          "src": "11985:29:136"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12316,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "502:50:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12320,
+          "type": "t_mapping<t_uint256>",
+          "src": "622:53:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12323,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "736:28:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12327,
+          "type": "t_mapping<t_uint256>",
+          "src": "835:51:138"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12656,
+          "type": "t_array:50<t_uint256>",
+          "src": "8858:29:138"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12726,
+          "type": "t_string",
+          "src": "323:20:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12728,
+          "type": "t_string",
+          "src": "370:22:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12732,
+          "type": "t_mapping<t_string>",
+          "src": "438:45:141"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12861,
+          "type": "t_array:50<t_uint256>",
+          "src": "2891:29:141"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1455,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1555,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12931,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:142"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1578,
+          "type": "t_struct<Roles.Role>",
+          "src": "327:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1678,
+          "type": "t_array:50<t_uint256>",
+          "src": "1193:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5445,
+          "type": "t_bool",
+          "src": "406:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5526,
+          "type": "t_array:50<t_uint256>",
+          "src": "1487:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 13076,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:144"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11725,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1100:63:136"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1455,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1578,
+            "type": "t_struct<Roles.Role>",
+            "src": "327:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x27a09abCA2c4d9F914dbC7BeA164b0e6b74Ce7a9"
+  },
+  "package": {
+    "address": "0x2a9e7B63514438906A83a1e320dBBD814D417002"
+  },
+  "provider": {
+    "address": "0xbC1628cAE5Ed8892b030864eb8e37e70d0a9594C"
+  },
+  "version": "2.2.3"
+}

.travis.yml

@@ -1,44 +0,0 @@
-dist: trusty
-sudo: false
-group: beta
-language: node_js
-node_js:
-  - "8"
-
-cache:
-  directories:
-    - node_modules
-
-jobs:
-  # XXX fast_finish doesn't work with stages yet. See
-  # https://github.com/travis-ci/travis-ci/issues/8425
-  # --elopio - 20180531
-  fast_finish: true
-  allow_failures:
-    - env: SOLC_NIGHTLY=true
-  include:
-    - stage: tests
-      name: "Linter"
-      script: npm run lint
-
-    - stage: tests
-      name: "Unit tests"
-      script: npm run test
-
-    - stage: tests
-      name: "Unit tests with coverage report"
-      script: npm run test
-      env: SOLIDITY_COVERAGE=true
-
-    - stage: tests
-      name: "Unit tests using solc nightly"
-      script: npm run test
-      env: SOLC_NIGHTLY=true
-
-notifications:
-  slack:
-    rooms:
-      - secure: uEhwUkuwJp5pBNh+VTEytPHz3FDKsnPrKO+8MTAKv5hKi4PCRoVhLv6pklr82HUpL6pvSvJbUPA0HVebOXA+MMSxdny/BHZTh2mtw5Y78l2Ad0svDTWuV2Lus2pmhYigRhT0Wo00/SRX9+pxm0kg4EIFJSTS+uR9G76x0l9NljpEGXrqxlDxjxoHBgk8Ciru2LHaLzX/utE3jlABts4Sb1F3wc2BwFkjd6BDCRTGAPhVJwwFk41ZfnmLVbgSNUyk46Cb38oG5oXHb0FI3d3jV/k1OUhRyFfmA2fLXRk0wavibW8TG1gGJJWZ7xTCKzw/Cvup6mpehSAeQef8eekMdjpWEhF9hYRq1BvOs0384UU8NQ0O+BtdXU+X3Nyr84TMJN/iIfgN7gYX7AsvXH3jC0JfNUcIkWlJvyXdE6l2GV1hMmhL09GFEBbSpuSXRIWlOXTcYBlp5NbvE8xO8PUW+T6N5RG2XXjv1g8wCpr6Wwk1+LmRkX5trv8MFBZ2pM8p4H5da5++Ov8egLonNGK2jbx6aBLBX3tPf+g70LZEkiQ4eBfZw8VIgXIvKreisicppNuCD27gNmSEPNt0NkwiEBcTCJ9GSVAO0CU2g4ggvHDX2A+RW5XPET9bGkBXKLfFyV7Qe+MSQjXkCnW3bIRh7Wo1V31XiUiYOLuZPIiH3EQ=
-    on_success: change
-    on_failure: always
-    on_pull_requests: false

CHANGELOG.md

@@ -1,23 +1,20 @@
 # Changelog
 
-## 2.3.0 (unreleased)
+## 2.2.2 (2019-08-12)
 
 ### New features:
- * `ERC1820`: added support for interacting with the [ERC1820](https://eips.ethereum.org/EIPS/eip-1820) registry contract (`IERC1820Registry`), as well as base contracts that can be registered as implementers there. ([#1677](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1677))
- * `ERC777`: initial support for the [ERC777 token](https://eips.ethereum.org/EIPS/eip-777), which has multiple improvements over `ERC20` such as built-in burning, a more  straightforward permission system, and optional sender and receiver hooks on transfer (mandatory for contracts!). ([#1684](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1684))
- * All contracts now have revert reason strings, which give insight into error conditions, and help debug failing transactions. ([#1704](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1704))
+ * Facilities to make metatransaction-enabled contracts through the Gas Station Network. Backported from [#1844](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1844).
 
-### Improvements:
- * Reverted the Solidity version bump done in v2.2.0, setting the minimum compiler version to v0.5.0, to prevent unexpected build breakage. Users are encouraged however to stay on top of new compiler releases, which usually include bugfixes. ([#1729](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1729))
+## 2.2.1 (2019-07-22)
 
-### Bugfixes:
- * `PostDeliveryCrowdsale`: some validations where skipped when paired with other crowdsale flavors, such as `AllowanceCrowdsale`, or `MintableCrowdsale` and `ERC20Capped`, which could cause buyers to not be able to claim their purchased tokens. ([#1721](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1721))
+### 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/1655))
+ * `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.
@@ -26,14 +23,14 @@
  * 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 in drafts:
- * `TokenMetadata` has been renamed to `ERC20Metadata`. ([#1618](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1618))
- * The library `Counter` has been renamed to `Counters` and its API has been improved. See an example in `ERC721`, lines [17](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/3cb4a00fce1da76196ac0ac3a0ae9702b99642b5/contracts/token/ERC721/ERC721.sol#L17) and [204](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/3cb4a00fce1da76196ac0ac3a0ae9702b99642b5/contracts/token/ERC721/ERC721.sol#L204). ([#1610](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1610))
+### 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))

DOCUMENTATION.md

@@ -1,19 +0,0 @@
-We're building an improved documentation website. It's still in development and
-contributions will be really appreciated.
-
-All of the content for the site is in this repository. The guides are in the
-[docs](/docs) directory, and the API Reference is extracted from comments in
-the source code. If you want to help improve the content, this is the
-repository you should be contributing to.
-
-[`solidity-docgen`](https://github.com/OpenZeppelin/solidity-docgen/tree/next) is the
-program that extracts the API Reference from source code.
-
-The [`openzeppelin-docsite`](https://github.com/OpenZeppelin/openzeppelin-docsite/tree/next)
-repository hosts the configuration for Docusaurus, the static site generator
-that we use.
-
-To run the docsite locally you should run `npm run docsite start` on this
-repository. This will live reload as the guides are edited, but not with
-changes to the source code comments, for that you need to restart the server.
-This should be improved eventually (contributions welcome!).

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016-2019 zOS Global Limited
+Copyright (c) 2016 Smart Contract Solutions, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

README.md

@@ -1,44 +1,98 @@
-# <img src="logo.png" alt="OpenZeppelin" width="400px">
+# <img src="logo.png" alt="OpenZeppelin" height="40px">
 
-[![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)](https://www.npmjs.org/package/@openzeppelin/contracts-ethereum-package)
+[![Build Status](https://circleci.com/gh/OpenZeppelin/openzeppelin-contracts-ethereum-package.svg?style=shield)](https://circleci.com/gh/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
 ```
 
-OpenZeppelin features a stable API, which means your contracts won't break unexpectedly when upgrading to a newer minor version. You can read ṫhe details in our [API Stability](https://forum.zeppelin.solutions/t/api-stability/138) document.
+## Deployed logic contracts
 
-## Usage
+- [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.
 
-To write your custom contracts, import ours and extend them through inheritance.
+## Using via the OpenZeppelin CLI
+
+You can easily create upgradeable instances of any of the logic contracts listed above using the OpenZeppelin CLI. This will rely on the pre-deployed instances in mainnet, kovan, ropsten, or rinkeby, greatly reducing your gas deployment costs. To do this, just [create a new OpenZeppelin SDK project](https://docs.zeppelinos.org/docs/deploying.html) and [link to this package](https://docs.zeppelinos.org/docs/linking.html).
+
+```bash
+$ npm install -g @openzeppelin/cli
+$ openzeppelin init
+$ openzeppelin link @openzeppelin/contracts-ethereum-package
+> Installing...
+$ openzeppelin create @openzeppelin/contracts-ethereum-package/StandaloneERC20
+> Creating...
+```
+
+To create an instance of a contract, use the `openzeppelin create` command. As an example, you can run the following to create an upgradeable ERC20 named MyToken, with symbol TKN and 8 decimals, and an initial supply of 100 tokens assigned to the address HOLDER, with a MINTER and a PAUSER. Remember to replace $HOLDER, $MINTER, and $PAUSER with actual addresses when you run this command; you can specify more than one (or none at all) minters and pausers.
+
+```
+$ openzeppelin create
+? Pick a contract to instantiate: @openzeppelin/contracts-ethereum-package/StandaloneERC20
+? Pick a network: development
+✓ Deploying @openzeppelin/contracts-ethereum-package dependency to network
+? Do you want to call a function on the instance after creating it?: Yes
+? Select which function: * initialize(name: string, symbol: string, decimals: uint8, initialSupply: uint256, initialHolder: address, minters: address[], pausers: address[])
+? name (string): MyToken
+? symbol (string): MYT
+? decimals (uint8): 18
+? initialSupply (uint256): 100e18
+? initialHolder (address): 0x90f8bf6a479f320ead074411a4b0e7944ea8c9c1
+? minters (address[]):
+? pausers (address[]):
+✓ Setting everything up to create contract instances
+✓ Instance created at 0x2612Af3A521c2df9EAF28422Ca335b04AdF3ac66
+```
+
+OpenZeppelin will create an upgradeable ERC20 instance and keep track of its address in the `.openzeppelin/rinkeby.json` file. Should you update your version of the openzeppelin contracts ethereum package later down the road, you can simply run `openzeppelin update` to upgrade all your ERC20 instances to the latest version.
+
+You can also deploy a ERC721 token by choosing the `StandaloneERC721` contract when running `openzeppelin create`. Refer to the `initialize` function of each of the predeployed logic contracts to see which parameters are required for initialization.
+
+## Extending contracts
+
+If you prefer to write your custom contracts, import the ones from this package and extend them through inheritance. Note that **you must use this package and not `@openzeppelin/contracts` if you are [writing upgradeable contracts](https://docs.zeppelinos.org/docs/writing_contracts.html)**.
 
 ```solidity
 pragma solidity ^0.5.0;
 
-import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol';
-import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Mintable.sol';
+import '@openzeppelin/upgrades/contracts/Initializable.sol';
+import '@openzeppelin/contracts-ethereum-package/contracts/token/ERC721/ERC721Full.sol';
+import '@openzeppelin/contracts-ethereum-package/contracts/token/ERC721/ERC721Mintable.sol';
 
-contract MyNFT is ERC721Full, ERC721Mintable {
-  constructor() ERC721Full("MyNFT", "MNFT") public {
+contract MyNFT is Initializable, ERC721Full, ERC721Mintable {
+  function initialize() public initializer {
+    ERC721.initialize();
+    ERC721Enumerable.initialize();
+    ERC721Metadata.initialize("MyNFT", "MNFT");
+    ERC721Mintable.initialize(msg.sender);
   }
 }
 ```
 
-> You need an ethereum development framework for the above import statements to work! Check out these guides for [Truffle], [Embark] or [Buidler].
-
 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.
 
@@ -52,12 +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
+[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
-[Zeppelin]: https://zeppelin.solutions
 [contribution guide]: CONTRIBUTING.md
-[Truffle]: https://truffleframework.com/docs/truffle/quickstart
-[Embark]: https://embark.status.im/docs/quick_start.html
-[Buidler]: https://buidler.dev/guides/#getting-started

RELEASING.md

@@ -40,7 +40,7 @@ Once the CI run for the new tag is green, publish on npm under the `next` tag. Y
 npm publish --tag next
 ```
 
-Publish the release notes on GitHub and the forum, and ask our community manager to announce the release candidate on at least Twitter.
+Publish the release notes on GitHub and ask our community manager to announce the release candidate on at least Slack and Twitter.
 
 ## Creating the final release
 

contracts/GSN/Context.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.5.0;
+
+/*
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they not should not be accessed in such a direct
+ * manner, since when dealing with GSN meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+contract Context {
+    // Empty internal constructor, to prevent people from mistakenly deploying
+    // an instance of this contract, with should be used via inheritance.
+    constructor () internal { }
+    // solhint-disable-previous-line no-empty-blocks
+
+    function _msgSender() internal view returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view returns (bytes memory) {
+        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+        return msg.data;
+    }
+}

contracts/GSN/GSNContext.sol

@@ -0,0 +1,103 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "./Context.sol";
+
+/*
+ * @dev Enables GSN support on `Context` contracts by recognizing calls from
+ * RelayHub and extracting the actual sender and call data from the received
+ * calldata.
+ *
+ * > This contract does not perform all required tasks to implement a GSN
+ * recipient contract: end users should use `GSNRecipient` instead.
+ */
+contract GSNContext is Initializable, Context {
+    // We use a random storage slot to allow proxy contracts to enable GSN support in an upgrade without changing their
+    // storage layout. This value is calculated as: keccak256('gsn.relayhub.address'), minus 1.
+    bytes32 private constant RELAY_HUB_ADDRESS_STORAGE_SLOT = 0x06b7792c761dcc05af1761f0315ce8b01ac39c16cc934eb0b2f7a8e71414f262;
+
+    event RelayHubChanged(address indexed oldRelayHub, address indexed newRelayHub);
+
+    function initialize() public initializer {
+        _upgradeRelayHub(0xD216153c06E857cD7f72665E0aF1d7D82172F494);
+    }
+
+    function _getRelayHub() internal view returns (address relayHub) {
+        bytes32 slot = RELAY_HUB_ADDRESS_STORAGE_SLOT;
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            relayHub := sload(slot)
+        }
+    }
+
+    function _upgradeRelayHub(address newRelayHub) internal {
+        address currentRelayHub = _getRelayHub();
+        require(newRelayHub != address(0), "GSNContext: new RelayHub is the zero address");
+        require(newRelayHub != currentRelayHub, "GSNContext: new RelayHub is the current one");
+
+        emit RelayHubChanged(currentRelayHub, newRelayHub);
+
+        bytes32 slot = RELAY_HUB_ADDRESS_STORAGE_SLOT;
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            sstore(slot, newRelayHub)
+        }
+    }
+
+    // Overrides for Context's functions: when called from RelayHub, sender and
+    // data require some pre-processing: the actual sender is stored at the end
+    // of the call data, which in turns means it needs to be removed from it
+    // when handling said data.
+
+    function _msgSender() internal view returns (address) {
+        if (msg.sender != _getRelayHub()) {
+            return msg.sender;
+        } else {
+            return _getRelayedCallSender();
+        }
+    }
+
+    function _msgData() internal view returns (bytes memory) {
+        if (msg.sender != _getRelayHub()) {
+            return msg.data;
+        } else {
+            return _getRelayedCallData();
+        }
+    }
+
+    function _getRelayedCallSender() private pure returns (address result) {
+        // We need to read 20 bytes (an address) located at array index msg.data.length - 20. In memory, the array
+        // is prefixed with a 32-byte length value, so we first add 32 to get the memory read index. However, doing
+        // so would leave the address in the upper 20 bytes of the 32-byte word, which is inconvenient and would
+        // require bit shifting. We therefore subtract 12 from the read index so the address lands on the lower 20
+        // bytes. This can always be done due to the 32-byte prefix.
+
+        // The final memory read index is msg.data.length - 20 + 32 - 12 = msg.data.length. Using inline assembly is the
+        // easiest/most-efficient way to perform this operation.
+
+        // These fields are not accessible from assembly
+        bytes memory array = msg.data;
+        uint256 index = msg.data.length;
+
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
+            result := and(mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff)
+        }
+        return result;
+    }
+
+    function _getRelayedCallData() private pure returns (bytes memory) {
+        // RelayHub appends the sender address at the end of the calldata, so in order to retrieve the actual msg.data,
+        // we must strip the last 20 bytes (length of an address type) from it.
+
+        uint256 actualDataLength = msg.data.length - 20;
+        bytes memory actualData = new bytes(actualDataLength);
+
+        for (uint256 i = 0; i < actualDataLength; ++i) {
+            actualData[i] = msg.data[i];
+        }
+
+        return actualData;
+    }
+}

contracts/GSN/GSNRecipient.sol

@@ -0,0 +1,33 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "./IRelayRecipient.sol";
+import "./GSNContext.sol";
+import "./bouncers/GSNBouncerBase.sol";
+import "./IRelayHub.sol";
+
+/*
+ * @dev Base GSN recipient contract, adding the recipient interface and enabling
+ * GSN support. Not all interface methods are implemented, derived contracts
+ * must do so themselves.
+ */
+contract GSNRecipient is Initializable, IRelayRecipient, GSNContext, GSNBouncerBase {
+    function initialize() public initializer {
+        GSNContext.initialize();
+    }
+
+    function getHubAddr() public view returns (address) {
+        return _getRelayHub();
+    }
+
+    // This function is view for future-proofing, it may require reading from
+    // storage in the future.
+    function relayHubVersion() public view returns (string memory) {
+        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+        return "1.0.0";
+    }
+
+    function _withdrawDeposits(uint256 amount, address payable payee) internal {
+        IRelayHub(_getRelayHub()).withdraw(amount, payee);
+    }
+}

contracts/GSN/IRelayHub.sol

@@ -0,0 +1,188 @@
+pragma solidity ^0.5.0;
+
+contract IRelayHub {
+    // Relay management
+
+    // Add stake to a relay and sets its unstakeDelay.
+    // If the relay does not exist, it is created, and the caller
+    // of this function becomes its owner. If the relay already exists, only the owner can call this function. A relay
+    // cannot be its own owner.
+    // All Ether in this function call will be added to the relay's stake.
+    // Its unstake delay will be assigned to unstakeDelay, but the new value must be greater or equal to the current one.
+    // Emits a Staked event.
+    function stake(address relayaddr, uint256 unstakeDelay) external payable;
+
+    // Emited when a relay's stake or unstakeDelay are increased
+    event Staked(address indexed relay, uint256 stake, uint256 unstakeDelay);
+
+    // Registers the caller as a relay.
+    // The relay must be staked for, and not be a contract (i.e. this function must be called directly from an EOA).
+    // Emits a RelayAdded event.
+    // This function can be called multiple times, emitting new RelayAdded events. Note that the received transactionFee
+    // is not enforced by relayCall.
+    function registerRelay(uint256 transactionFee, string memory url) public;
+
+    // Emitted when a relay is registered or re-registerd. Looking at these events (and filtering out RelayRemoved
+    // events) lets a client discover the list of available relays.
+    event RelayAdded(address indexed relay, address indexed owner, uint256 transactionFee, uint256 stake, uint256 unstakeDelay, string url);
+
+    // Removes (deregisters) a relay. Unregistered (but staked for) relays can also be removed. Can only be called by
+    // the owner of the relay. After the relay's unstakeDelay has elapsed, unstake will be callable.
+    // Emits a RelayRemoved event.
+    function removeRelayByOwner(address relay) public;
+
+    // Emitted when a relay is removed (deregistered). unstakeTime is the time when unstake will be callable.
+    event RelayRemoved(address indexed relay, uint256 unstakeTime);
+
+    // Deletes the relay from the system, and gives back its stake to the owner. Can only be called by the relay owner,
+    // after unstakeDelay has elapsed since removeRelayByOwner was called.
+    // Emits an Unstaked event.
+    function unstake(address relay) public;
+
+    // Emitted when a relay is unstaked for, including the returned stake.
+    event Unstaked(address indexed relay, uint256 stake);
+
+    // States a relay can be in
+    enum RelayState {
+        Unknown, // The relay is unknown to the system: it has never been staked for
+        Staked, // The relay has been staked for, but it is not yet active
+        Registered, // The relay has registered itself, and is active (can relay calls)
+        Removed    // The relay has been removed by its owner and can no longer relay calls. It must wait for its unstakeDelay to elapse before it can unstake
+    }
+
+    // Returns a relay's status. Note that relays can be deleted when unstaked or penalized.
+    function getRelay(address relay) external view returns (uint256 totalStake, uint256 unstakeDelay, uint256 unstakeTime, address payable owner, RelayState state);
+
+    // Balance management
+
+    // Deposits ether for a contract, so that it can receive (and pay for) relayed transactions. Unused balance can only
+    // be withdrawn by the contract itself, by callingn withdraw.
+    // Emits a Deposited event.
+    function depositFor(address target) public payable;
+
+    // Emitted when depositFor is called, including the amount and account that was funded.
+    event Deposited(address indexed recipient, address indexed from, uint256 amount);
+
+    // Returns an account's deposits. These can be either a contnract's funds, or a relay owner's revenue.
+    function balanceOf(address target) external view returns (uint256);
+
+    // Withdraws from an account's balance, sending it back to it. Relay owners call this to retrieve their revenue, and
+    // contracts can also use it to reduce their funding.
+    // Emits a Withdrawn event.
+    function withdraw(uint256 amount, address payable dest) public;
+
+    // Emitted when an account withdraws funds from RelayHub.
+    event Withdrawn(address indexed account, address indexed dest, uint256 amount);
+
+    // Relaying
+
+    // Check if the RelayHub will accept a relayed operation. Multiple things must be true for this to happen:
+    //  - all arguments must be signed for by the sender (from)
+    //  - the sender's nonce must be the current one
+    //  - the recipient must accept this transaction (via acceptRelayedCall)
+    // Returns a PreconditionCheck value (OK when the transaction can be relayed), or a recipient-specific error code if
+    // it returns one in acceptRelayedCall.
+    function canRelay(
+        address relay,
+        address from,
+        address to,
+        bytes memory encodedFunction,
+        uint256 transactionFee,
+        uint256 gasPrice,
+        uint256 gasLimit,
+        uint256 nonce,
+        bytes memory signature,
+        bytes memory approvalData
+    ) public view returns (uint256 status, bytes memory recipientContext);
+
+    // Preconditions for relaying, checked by canRelay and returned as the corresponding numeric values.
+    enum PreconditionCheck {
+        OK,                         // All checks passed, the call can be relayed
+        WrongSignature,             // The transaction to relay is not signed by requested sender
+        WrongNonce,                 // The provided nonce has already been used by the sender
+        AcceptRelayedCallReverted,  // The recipient rejected this call via acceptRelayedCall
+        InvalidRecipientStatusCode  // The recipient returned an invalid (reserved) status code
+    }
+
+    // Relays a transaction. For this to suceed, multiple conditions must be met:
+    //  - canRelay must return PreconditionCheck.OK
+    //  - the sender must be a registered relay
+    //  - the transaction's gas price must be larger or equal to the one that was requested by the sender
+    //  - the transaction must have enough gas to not run out of gas if all internal transactions (calls to the
+    // recipient) use all gas available to them
+    //  - the recipient must have enough balance to pay the relay for the worst-case scenario (i.e. when all gas is
+    // spent)
+    //
+    // If all conditions are met, the call will be relayed and the recipient charged. preRelayedCall, the encoded
+    // function and postRelayedCall will be called in order.
+    //
+    // Arguments:
+    //  - from: the client originating the request
+    //  - recipient: the target IRelayRecipient contract
+    //  - encodedFunction: the function call to relay, including data
+    //  - transactionFee: fee (%) the relay takes over actual gas cost
+    //  - gasPrice: gas price the client is willing to pay
+    //  - gasLimit: gas to forward when calling the encoded function
+    //  - nonce: client's nonce
+    //  - signature: client's signature over all previous params, plus the relay and RelayHub addresses
+    //  - approvalData: dapp-specific data forwared to acceptRelayedCall. This value is *not* verified by the Hub, but
+    //    it still can be used for e.g. a signature.
+    //
+    // Emits a TransactionRelayed event.
+    function relayCall(
+        address from,
+        address to,
+        bytes memory encodedFunction,
+        uint256 transactionFee,
+        uint256 gasPrice,
+        uint256 gasLimit,
+        uint256 nonce,
+        bytes memory signature,
+        bytes memory approvalData
+    ) public;
+
+    // Emitted when an attempt to relay a call failed. This can happen due to incorrect relayCall arguments, or the
+    // recipient not accepting the relayed call. The actual relayed call was not executed, and the recipient not charged.
+    // The reason field contains an error code: values 1-10 correspond to PreconditionCheck entries, and values over 10
+    // are custom recipient error codes returned from acceptRelayedCall.
+    event CanRelayFailed(address indexed relay, address indexed from, address indexed to, bytes4 selector, uint256 reason);
+
+    // Emitted when a transaction is relayed. Note that the actual encoded function might be reverted: this will be
+    // indicated in the status field.
+    // Useful when monitoring a relay's operation and relayed calls to a contract.
+    // Charge is the ether value deducted from the recipient's balance, paid to the relay's owner.
+    event TransactionRelayed(address indexed relay, address indexed from, address indexed to, bytes4 selector, RelayCallStatus status, uint256 charge);
+
+    // Reason error codes for the TransactionRelayed event
+    enum RelayCallStatus {
+        OK,                      // The transaction was successfully relayed and execution successful - never included in the event
+        RelayedCallFailed,       // The transaction was relayed, but the relayed call failed
+        PreRelayedFailed,        // The transaction was not relayed due to preRelatedCall reverting
+        PostRelayedFailed,       // The transaction was relayed and reverted due to postRelatedCall reverting
+        RecipientBalanceChanged  // The transaction was relayed and reverted due to the recipient's balance changing
+    }
+
+    // Returns how much gas should be forwarded to a call to relayCall, in order to relay a transaction that will spend
+    // up to relayedCallStipend gas.
+    function requiredGas(uint256 relayedCallStipend) public view returns (uint256);
+
+    // Returns the maximum recipient charge, given the amount of gas forwarded, gas price and relay fee.
+    function maxPossibleCharge(uint256 relayedCallStipend, uint256 gasPrice, uint256 transactionFee) public view returns (uint256);
+
+    // Relay penalization. Any account can penalize relays, removing them from the system immediately, and rewarding the
+    // reporter with half of the relay's stake. The other half is burned so that, even if the relay penalizes itself, it
+    // still loses half of its stake.
+
+    // Penalize a relay that signed two transactions using the same nonce (making only the first one valid) and
+    // different data (gas price, gas limit, etc. may be different). The (unsigned) transaction data and signature for
+    // both transactions must be provided.
+    function penalizeRepeatedNonce(bytes memory unsignedTx1, bytes memory signature1, bytes memory unsignedTx2, bytes memory signature2) public;
+
+    // Penalize a relay that sent a transaction that didn't target RelayHub's registerRelay or relayCall.
+    function penalizeIllegalTransaction(bytes memory unsignedTx, bytes memory signature) public;
+
+    event Penalized(address indexed relay, address sender, uint256 amount);
+
+    function getNonce(address from) external view returns (uint256);
+}
+

contracts/GSN/IRelayRecipient.sol

@@ -0,0 +1,30 @@
+pragma solidity ^0.5.0;
+
+/*
+ * @dev Interface for a contract that will be called via the GSN from RelayHub.
+ */
+contract IRelayRecipient {
+    /**
+     * @dev Returns the address of the RelayHub instance this recipient interacts with.
+     */
+    function getHubAddr() public view returns (address);
+
+    function acceptRelayedCall(
+        address relay,
+        address from,
+        bytes calldata encodedFunction,
+        uint256 transactionFee,
+        uint256 gasPrice,
+        uint256 gasLimit,
+        uint256 nonce,
+        bytes calldata approvalData,
+        uint256 maxPossibleCharge
+    )
+        external
+        view
+        returns (uint256, bytes memory);
+
+    function preRelayedCall(bytes calldata context) external returns (bytes32);
+
+    function postRelayedCall(bytes calldata context, bool success, uint actualCharge, bytes32 preRetVal) external;
+}

contracts/GSN/bouncers/GSNBouncerBase.sol

@@ -0,0 +1,92 @@
+pragma solidity ^0.5.0;
+
+import "../IRelayRecipient.sol";
+
+/*
+ * @dev Base contract used to implement GSNBouncers.
+ *
+ * > This contract does not perform all required tasks to implement a GSN
+ * recipient contract: end users should use `GSNRecipient` instead.
+ */
+contract GSNBouncerBase is IRelayRecipient {
+    uint256 constant private RELAYED_CALL_ACCEPTED = 0;
+    uint256 constant private RELAYED_CALL_REJECTED = 11;
+
+    // How much gas is forwarded to postRelayedCall
+    uint256 constant internal POST_RELAYED_CALL_MAX_GAS = 100000;
+
+    // Base implementations for pre and post relayedCall: only RelayHub can invoke them, and data is forwarded to the
+    // internal hook.
+
+    /**
+     * @dev See `IRelayRecipient.preRelayedCall`.
+     *
+     * This function should not be overriden directly, use `_preRelayedCall` instead.
+     *
+     * * Requirements:
+     *
+     * - the caller must be the `RelayHub` contract.
+     */
+    function preRelayedCall(bytes calldata context) external returns (bytes32) {
+        require(msg.sender == getHubAddr(), "GSNBouncerBase: caller is not RelayHub");
+        return _preRelayedCall(context);
+    }
+
+    /**
+     * @dev See `IRelayRecipient.postRelayedCall`.
+     *
+     * This function should not be overriden directly, use `_postRelayedCall` instead.
+     *
+     * * Requirements:
+     *
+     * - the caller must be the `RelayHub` contract.
+     */
+    function postRelayedCall(bytes calldata context, bool success, uint256 actualCharge, bytes32 preRetVal) external {
+        require(msg.sender == getHubAddr(), "GSNBouncerBase: caller is not RelayHub");
+        _postRelayedCall(context, success, actualCharge, preRetVal);
+    }
+
+    /**
+     * @dev Return this in acceptRelayedCall to proceed with the execution of a relayed call. Note that this contract
+     * will be charged a fee by RelayHub
+     */
+    function _approveRelayedCall() internal pure returns (uint256, bytes memory) {
+        return _approveRelayedCall("");
+    }
+
+    /**
+     * @dev See `GSNBouncerBase._approveRelayedCall`.
+     *
+     * This overload forwards `context` to _preRelayedCall and _postRelayedCall.
+     */
+    function _approveRelayedCall(bytes memory context) internal pure returns (uint256, bytes memory) {
+        return (RELAYED_CALL_ACCEPTED, context);
+    }
+
+    /**
+     * @dev Return this in acceptRelayedCall to impede execution of a relayed call. No fees will be charged.
+     */
+    function _rejectRelayedCall(uint256 errorCode) internal pure returns (uint256, bytes memory) {
+        return (RELAYED_CALL_REJECTED + errorCode, "");
+    }
+
+    // Empty hooks for pre and post relayed call: users only have to define these if they actually use them.
+
+    function _preRelayedCall(bytes memory) internal returns (bytes32) {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    function _postRelayedCall(bytes memory, bool, uint256, bytes32) internal {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    /*
+     * @dev Calculates how much RelaHub will charge a recipient for using `gas` at a `gasPrice`, given a relayer's
+     * `serviceFee`.
+     */
+    function _computeCharge(uint256 gas, uint256 gasPrice, uint256 serviceFee) internal pure returns (uint256) {
+        // The fee is expressed as a percentage. E.g. a value of 40 stands for a 40% fee, so the recipient will be
+        // charged for 1.4 times the spent amount.
+        return (gas * gasPrice * (100 + serviceFee)) / 100;
+    }
+}

contracts/GSN/bouncers/GSNBouncerERC20Fee.sol

@@ -0,0 +1,143 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "./GSNBouncerBase.sol";
+import "../../math/SafeMath.sol";
+import "../../ownership/Secondary.sol";
+import "../../token/ERC20/SafeERC20.sol";
+import "../../token/ERC20/ERC20.sol";
+import "../../token/ERC20/ERC20Detailed.sol";
+
+contract GSNBouncerERC20Fee is Initializable, GSNBouncerBase {
+    using SafeERC20 for __unstable__ERC20PrimaryAdmin;
+    using SafeMath for uint256;
+
+    enum GSNBouncerERC20FeeErrorCodes {
+        INSUFFICIENT_BALANCE
+    }
+
+    // We use a random storage slot to allow proxy contracts to enable GSN support in an upgrade without changing their
+    // storage layout. This value is calculated as: keccak256('gsn.bouncer.signature.token'), minus 1.
+    bytes32 constant private TOKEN_STORAGE_SLOT = 0xd918b70a5a5c95a8c0cac8acbdd59e1b4acd0645f53c0461d64b41f8825c8828;
+
+    function initialize(string memory name, string memory symbol, uint8 decimals) public initializer {
+        // TODO: Should we inject this token, instead of creating it, in order to make it upgradeable?
+        // However, that would mean removing it from unstable and making in an official contract
+        _setToken(new __unstable__ERC20PrimaryAdmin(name, symbol, decimals));
+    }
+
+    function token() public view returns (IERC20) {
+        return IERC20(_getToken());
+    }
+
+    function _mint(address account, uint256 amount) internal {
+        _getToken().mint(account, amount);
+    }
+
+    function acceptRelayedCall(
+        address,
+        address from,
+        bytes calldata,
+        uint256 transactionFee,
+        uint256 gasPrice,
+        uint256,
+        uint256,
+        bytes calldata,
+        uint256 maxPossibleCharge
+    )
+        external
+        view
+        returns (uint256, bytes memory)
+    {
+        if (_getToken().balanceOf(from) < maxPossibleCharge) {
+            return _rejectRelayedCall(uint256(GSNBouncerERC20FeeErrorCodes.INSUFFICIENT_BALANCE));
+        }
+
+        return _approveRelayedCall(abi.encode(from, maxPossibleCharge, transactionFee, gasPrice));
+    }
+
+    function _preRelayedCall(bytes memory context) internal returns (bytes32) {
+        (address from, uint256 maxPossibleCharge) = abi.decode(context, (address, uint256));
+
+        // The maximum token charge is pre-charged from the user
+        _getToken().safeTransferFrom(from, address(this), maxPossibleCharge);
+    }
+
+    function _postRelayedCall(bytes memory context, bool, uint256 actualCharge, bytes32) internal {
+        (address from, uint256 maxPossibleCharge, uint256 transactionFee, uint256 gasPrice) =
+            abi.decode(context, (address, uint256, uint256, uint256));
+
+        // actualCharge is an _estimated_ charge, which assumes postRelayedCall will use all available gas.
+        // This implementation's gas cost can be roughly estimated as 10k gas, for the two SSTORE operations in an
+        // ERC20 transfer.
+        uint256 overestimation = _computeCharge(POST_RELAYED_CALL_MAX_GAS.sub(10000), gasPrice, transactionFee);
+        actualCharge = actualCharge.sub(overestimation);
+
+        // After the relayed call has been executed and the actual charge estimated, the excess pre-charge is returned
+        _getToken().safeTransfer(from, maxPossibleCharge.sub(actualCharge));
+    }
+
+    function _getToken() private view returns (__unstable__ERC20PrimaryAdmin token) {
+      bytes32 slot = TOKEN_STORAGE_SLOT;
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        token := sload(slot)
+      }
+    }
+
+    function _setToken(__unstable__ERC20PrimaryAdmin token) private {
+      bytes32 slot = TOKEN_STORAGE_SLOT;
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        sstore(slot, token)
+      }
+    }
+}
+
+/**
+ * @title __unstable__ERC20PrimaryAdmin
+ * @dev An ERC20 token owned by another contract, which has minting permissions and can use transferFrom to receive
+ * anyone's tokens. This contract is an internal helper for GSNRecipientERC20Fee, and should not be used
+ * outside of this context.
+ */
+// solhint-disable-next-line contract-name-camelcase
+contract __unstable__ERC20PrimaryAdmin is ERC20, ERC20Detailed, Secondary {
+    uint256 private constant UINT256_MAX = 2**256 - 1;
+
+    constructor(string memory name, string memory symbol, uint8 decimals) public {
+        Secondary.initialize(msg.sender);
+        ERC20Detailed.initialize(name, symbol, decimals);
+    }
+
+    // The primary account (GSNRecipientERC20Fee) can mint tokens
+    function mint(address account, uint256 amount) public onlyPrimary {
+        _mint(account, amount);
+    }
+
+    // The primary account has 'infinite' allowance for all token holders
+    function allowance(address owner, address spender) public view returns (uint256) {
+        if (spender == primary()) {
+            return UINT256_MAX;
+        } else {
+            return super.allowance(owner, spender);
+        }
+    }
+
+    // Allowance for the primary account cannot be changed (it is always 'infinite')
+    function _approve(address owner, address spender, uint256 value) internal {
+        if (spender == primary()) {
+            return;
+        } else {
+            super._approve(owner, spender, value);
+        }
+    }
+
+    function transferFrom(address sender, address recipient, uint256 amount) public returns (bool) {
+        if (recipient == primary()) {
+            _transfer(sender, recipient, amount);
+            return true;
+        } else {
+            return super.transferFrom(sender, recipient, amount);
+        }
+    }
+}

contracts/GSN/bouncers/GSNBouncerSignature.sol

@@ -0,0 +1,70 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "./GSNBouncerBase.sol";
+import "../../cryptography/ECDSA.sol";
+
+contract GSNBouncerSignature is Initializable, GSNBouncerBase {
+    using ECDSA for bytes32;
+
+    // We use a random storage slot to allow proxy contracts to enable GSN support in an upgrade without changing their
+    // storage layout. This value is calculated as: keccak256('gsn.bouncer.signature.trustedSigner'), minus 1.
+    bytes32 constant private TRUSTED_SIGNER_STORAGE_SLOT = 0xe7b237a4017a399d277819456dce32c2356236bbc518a6d84a9a8d1cfdf1e9c5;
+
+    enum GSNBouncerSignatureErrorCodes {
+        INVALID_SIGNER
+    }
+
+    function initialize(address trustedSigner) public initializer {
+        _setTrustedSigner(trustedSigner);
+    }
+
+    function acceptRelayedCall(
+        address relay,
+        address from,
+        bytes calldata encodedFunction,
+        uint256 transactionFee,
+        uint256 gasPrice,
+        uint256 gasLimit,
+        uint256 nonce,
+        bytes calldata approvalData,
+        uint256
+    )
+        external
+        view
+        returns (uint256, bytes memory)
+    {
+        bytes memory blob = abi.encodePacked(
+            relay,
+            from,
+            encodedFunction,
+            transactionFee,
+            gasPrice,
+            gasLimit,
+            nonce, // Prevents replays on RelayHub
+            getHubAddr(), // Prevents replays in multiple RelayHubs
+            address(this) // Prevents replays in multiple recipients
+        );
+        if (keccak256(blob).toEthSignedMessageHash().recover(approvalData) == _getTrustedSigner()) {
+            return _approveRelayedCall();
+        } else {
+            return _rejectRelayedCall(uint256(GSNBouncerSignatureErrorCodes.INVALID_SIGNER));
+        }
+    }
+
+    function _getTrustedSigner() private view returns (address trustedSigner) {
+      bytes32 slot = TRUSTED_SIGNER_STORAGE_SLOT;
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        trustedSigner := sload(slot)
+      }
+    }
+
+    function _setTrustedSigner(address trustedSigner) private {
+      bytes32 slot = TRUSTED_SIGNER_STORAGE_SLOT;
+      // solhint-disable-next-line no-inline-assembly
+      assembly {
+        sstore(slot, trustedSigner)
+      }
+    }
+}

contracts/access/README.md

@@ -1,7 +0,0 @@
----
-sections:
-  - title: Library
-    contracts:
-      - Roles
-  - subdirectory: roles
----

contracts/access/Roles.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title Roles
@@ -10,27 +10,31 @@ library Roles {
     }
 
     /**
-     * @dev Give an account access to this role.
+     * @dev give an account access to this role
      */
     function add(Role storage role, address account) internal {
-        require(!has(role, account), "Roles: account already has role");
+        require(account != address(0));
+        require(!has(role, account));
+
         role.bearer[account] = true;
     }
 
     /**
-     * @dev Remove an account's access to this role.
+     * @dev remove an account's access to this role
      */
     function remove(Role storage role, address account) internal {
-        require(has(role, account), "Roles: account does not have role");
+        require(account != address(0));
+        require(has(role, account));
+
         role.bearer[account] = false;
     }
 
     /**
-     * @dev Check if an account has this role.
+     * @dev check if an account has this role
      * @return bool
      */
     function has(Role storage role, address account) internal view returns (bool) {
-        require(account != address(0), "Roles: account is the zero address");
+        require(account != address(0));
         return role.bearer[account];
     }
 }

contracts/access/roles/CapperRole.sol

@@ -1,8 +1,11 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../Roles.sol";
 
-contract CapperRole {
+contract CapperRole is Initializable, Context {
     using Roles for Roles.Role;
 
     event CapperAdded(address indexed account);
@@ -10,12 +13,14 @@ contract CapperRole {
 
     Roles.Role private _cappers;
 
-    constructor () internal {
-        _addCapper(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isCapper(sender)) {
+            _addCapper(sender);
+        }
     }
 
     modifier onlyCapper() {
-        require(isCapper(msg.sender), "CapperRole: caller does not have the Capper role");
+        require(isCapper(_msgSender()), "CapperRole: caller does not have the Capper role");
         _;
     }
 
@@ -28,7 +33,7 @@ contract CapperRole {
     }
 
     function renounceCapper() public {
-        _removeCapper(msg.sender);
+        _removeCapper(_msgSender());
     }
 
     function _addCapper(address account) internal {
@@ -40,4 +45,6 @@ contract CapperRole {
         _cappers.remove(account);
         emit CapperRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/MinterRole.sol

@@ -1,8 +1,11 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../Roles.sol";
 
-contract MinterRole {
+contract MinterRole is Initializable, Context {
     using Roles for Roles.Role;
 
     event MinterAdded(address indexed account);
@@ -10,12 +13,14 @@ contract MinterRole {
 
     Roles.Role private _minters;
 
-    constructor () internal {
-        _addMinter(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isMinter(sender)) {
+            _addMinter(sender);
+        }
     }
 
     modifier onlyMinter() {
-        require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
+        require(isMinter(_msgSender()), "MinterRole: caller does not have the Minter role");
         _;
     }
 
@@ -28,7 +33,7 @@ contract MinterRole {
     }
 
     function renounceMinter() public {
-        _removeMinter(msg.sender);
+        _removeMinter(_msgSender());
     }
 
     function _addMinter(address account) internal {
@@ -40,4 +45,6 @@ contract MinterRole {
         _minters.remove(account);
         emit MinterRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/PauserRole.sol

@@ -1,8 +1,11 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../Roles.sol";
 
-contract PauserRole {
+contract PauserRole is Initializable, Context {
     using Roles for Roles.Role;
 
     event PauserAdded(address indexed account);
@@ -10,12 +13,14 @@ contract PauserRole {
 
     Roles.Role private _pausers;
 
-    constructor () internal {
-        _addPauser(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isPauser(sender)) {
+            _addPauser(sender);
+        }
     }
 
     modifier onlyPauser() {
-        require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
+        require(isPauser(_msgSender()), "PauserRole: caller does not have the Pauser role");
         _;
     }
 
@@ -28,7 +33,7 @@ contract PauserRole {
     }
 
     function renouncePauser() public {
-        _removePauser(msg.sender);
+        _removePauser(_msgSender());
     }
 
     function _addPauser(address account) internal {
@@ -40,4 +45,6 @@ contract PauserRole {
         _pausers.remove(account);
         emit PauserRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/SignerRole.sol

@@ -1,8 +1,11 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../Roles.sol";
 
-contract SignerRole {
+contract SignerRole is Initializable, Context {
     using Roles for Roles.Role;
 
     event SignerAdded(address indexed account);
@@ -10,12 +13,14 @@ contract SignerRole {
 
     Roles.Role private _signers;
 
-    constructor () internal {
-        _addSigner(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isSigner(sender)) {
+            _addSigner(sender);
+        }
     }
 
     modifier onlySigner() {
-        require(isSigner(msg.sender), "SignerRole: caller does not have the Signer role");
+        require(isSigner(_msgSender()), "SignerRole: caller does not have the Signer role");
         _;
     }
 
@@ -28,7 +33,7 @@ contract SignerRole {
     }
 
     function renounceSigner() public {
-        _removeSigner(msg.sender);
+        _removeSigner(_msgSender());
     }
 
     function _addSigner(address account) internal {
@@ -40,4 +45,6 @@ contract SignerRole {
         _signers.remove(account);
         emit SignerRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/WhitelistAdminRole.sol

@@ -1,12 +1,15 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../Roles.sol";
 
 /**
  * @title WhitelistAdminRole
  * @dev WhitelistAdmins are responsible for assigning and removing Whitelisted accounts.
  */
-contract WhitelistAdminRole {
+contract WhitelistAdminRole is Initializable, Context {
     using Roles for Roles.Role;
 
     event WhitelistAdminAdded(address indexed account);
@@ -14,12 +17,14 @@ contract WhitelistAdminRole {
 
     Roles.Role private _whitelistAdmins;
 
-    constructor () internal {
-        _addWhitelistAdmin(msg.sender);
+    function initialize(address sender) public initializer {
+        if (!isWhitelistAdmin(sender)) {
+            _addWhitelistAdmin(sender);
+        }
     }
 
     modifier onlyWhitelistAdmin() {
-        require(isWhitelistAdmin(msg.sender), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
+        require(isWhitelistAdmin(_msgSender()), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
         _;
     }
 
@@ -32,7 +37,7 @@ contract WhitelistAdminRole {
     }
 
     function renounceWhitelistAdmin() public {
-        _removeWhitelistAdmin(msg.sender);
+        _removeWhitelistAdmin(_msgSender());
     }
 
     function _addWhitelistAdmin(address account) internal {
@@ -44,4 +49,6 @@ contract WhitelistAdminRole {
         _whitelistAdmins.remove(account);
         emit WhitelistAdminRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/access/roles/WhitelistedRole.sol

@@ -1,5 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../Roles.sol";
 import "./WhitelistAdminRole.sol";
 
@@ -9,7 +12,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, Context, WhitelistAdminRole {
     using Roles for Roles.Role;
 
     event WhitelistedAdded(address indexed account);
@@ -18,10 +21,14 @@ contract WhitelistedRole is WhitelistAdminRole {
     Roles.Role private _whitelisteds;
 
     modifier onlyWhitelisted() {
-        require(isWhitelisted(msg.sender), "WhitelistedRole: caller does not have the Whitelisted role");
+        require(isWhitelisted(_msgSender()), "WhitelistedRole: caller does not have the Whitelisted role");
         _;
     }
 
+    function initialize(address sender) public initializer {
+        WhitelistAdminRole.initialize(sender);
+    }
+
     function isWhitelisted(address account) public view returns (bool) {
         return _whitelisteds.has(account);
     }
@@ -35,7 +42,7 @@ contract WhitelistedRole is WhitelistAdminRole {
     }
 
     function renounceWhitelisted() public {
-        _removeWhitelisted(msg.sender);
+        _removeWhitelisted(_msgSender());
     }
 
     function _addWhitelisted(address account) internal {
@@ -47,4 +54,6 @@ contract WhitelistedRole is WhitelistAdminRole {
         _whitelisteds.remove(account);
         emit WhitelistedRemoved(account);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/Crowdsale.sol

@@ -1,5 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../GSN/Context.sol";
 import "../token/ERC20/IERC20.sol";
 import "../math/SafeMath.sol";
 import "../token/ERC20/SafeERC20.sol";
@@ -17,7 +20,7 @@ import "../utils/ReentrancyGuard.sol";
  * the methods to add functionality. Consider using 'super' where appropriate to concatenate
  * behavior.
  */
-contract Crowdsale is ReentrancyGuard {
+contract Crowdsale is Initializable, Context, ReentrancyGuard {
     using SafeMath for uint256;
     using SafeERC20 for IERC20;
 
@@ -53,10 +56,10 @@ contract Crowdsale is ReentrancyGuard {
      * @param wallet Address where collected funds will be forwarded to
      * @param token Address of the token being sold
      */
-    constructor (uint256 rate, address payable wallet, IERC20 token) public {
-        require(rate > 0, "Crowdsale: rate is 0");
-        require(wallet != address(0), "Crowdsale: wallet is the zero address");
-        require(address(token) != address(0), "Crowdsale: token is the zero address");
+    function initialize(uint256 rate, address payable wallet, IERC20 token) public initializer {
+        require(rate > 0);
+        require(wallet != address(0));
+        require(address(token) != address(0));
 
         _rate = rate;
         _wallet = wallet;
@@ -70,7 +73,7 @@ contract Crowdsale is ReentrancyGuard {
      * buyTokens directly when purchasing tokens from a contract.
      */
     function () external payable {
-        buyTokens(msg.sender);
+        buyTokens(_msgSender());
     }
 
     /**
@@ -118,7 +121,7 @@ contract Crowdsale is ReentrancyGuard {
         _weiRaised = _weiRaised.add(weiAmount);
 
         _processPurchase(beneficiary, tokens);
-        emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
+        emit TokensPurchased(_msgSender(), beneficiary, weiAmount, tokens);
 
         _updatePurchasingState(beneficiary, weiAmount);
 
@@ -126,6 +129,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.
@@ -136,8 +143,8 @@ contract Crowdsale is ReentrancyGuard {
      * @param weiAmount Value in wei involved in the purchase
      */
     function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
-        require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
-        require(weiAmount != 0, "Crowdsale: weiAmount is 0");
+        require(beneficiary != address(0));
+        require(weiAmount != 0);
     }
 
     /**
@@ -195,4 +202,6 @@ contract Crowdsale is ReentrancyGuard {
     function _forwardFunds() internal {
         _wallet.transfer(msg.value);
     }
+
+    uint256[50] private ______gap;
 }

contracts/crowdsale/README.md

@@ -1,11 +0,0 @@
----
-title: Crowdsales
-sections:
-  - title: Core
-    contracts:
-      - Crowdsale
-  - subdirectory: emission
-  - subdirectory: price
-  - subdirectory: validation
-  - subdirectory: distribution
----

contracts/crowdsale/distribution/FinalizableCrowdsale.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 "../validation/TimedCrowdsale.sol";
 
@@ -8,17 +9,13 @@ import "../validation/TimedCrowdsale.sol";
  * @dev Extension of TimedCrowdsale with a one-off finalization action, where one
  * can do extra work after finishing.
  */
-contract FinalizableCrowdsale is TimedCrowdsale {
+contract FinalizableCrowdsale is Initializable, TimedCrowdsale {
     using SafeMath for uint256;
 
     bool private _finalized;
 
     event CrowdsaleFinalized();
 
-    constructor () internal {
-        _finalized = false;
-    }
-
     /**
      * @return true if the crowdsale is finalized, false otherwise.
      */
@@ -31,8 +28,8 @@ contract FinalizableCrowdsale is TimedCrowdsale {
      * work. Calls the contract's finalization function.
      */
     function finalize() public {
-        require(!_finalized, "FinalizableCrowdsale: already finalized");
-        require(hasClosed(), "FinalizableCrowdsale: not closed");
+        require(!_finalized);
+        require(hasClosed());
 
         _finalized = true;
 
@@ -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,35 +1,28 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../validation/TimedCrowdsale.sol";
 import "../../math/SafeMath.sol";
-import "../../ownership/Secondary.sol";
-import "../../token/ERC20/IERC20.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;
-    __unstable__TokenVault private _vault;
-
-    constructor() public {
-        _vault = new __unstable__TokenVault();
-    }
 
     /**
      * @dev Withdraw tokens only after crowdsale ends.
      * @param beneficiary Whose tokens will be withdrawn.
      */
     function withdrawTokens(address beneficiary) public {
-        require(hasClosed(), "PostDeliveryCrowdsale: not closed");
+        require(hasClosed());
         uint256 amount = _balances[beneficiary];
-        require(amount > 0, "PostDeliveryCrowdsale: beneficiary is not due any tokens");
-
+        require(amount > 0);
         _balances[beneficiary] = 0;
-        _vault.transfer(token(), beneficiary, amount);
+        _deliverTokens(beneficiary, amount);
     }
 
     /**
@@ -40,26 +33,13 @@ contract PostDeliveryCrowdsale is TimedCrowdsale {
     }
 
     /**
-     * @dev Overrides parent by storing due balances, and delivering tokens to the vault instead of the end user. This
-     * ensures that the tokens will be available by the time they are withdrawn (which may not be the case if
-     * `_deliverTokens` was called later).
+     * @dev Overrides parent by storing balances instead of issuing tokens right away.
      * @param beneficiary Token purchaser
      * @param tokenAmount Amount of tokens purchased
      */
     function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
         _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
-        _deliverTokens(address(_vault), tokenAmount);
     }
-}
 
-/**
- * @title __unstable__TokenVault
- * @dev Similar to an Escrow for tokens, this contract allows its primary account to spend its tokens as it sees fit.
- * This contract is an internal helper for PostDeliveryCrowdsale, and should not be used outside of this context.
- */
-// solhint-disable-next-line contract-name-camelcase
-contract __unstable__TokenVault is Secondary {
-    function transfer(IERC20 token, address to, uint256 amount) public onlyPrimary {
-        token.transfer(to, amount);
-    }
+    uint256[50] private ______gap;
 }

contracts/crowdsale/distribution/RefundableCrowdsale.sol

@@ -1,5 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../../GSN/Context.sol";
 import "../../math/SafeMath.sol";
 import "./FinalizableCrowdsale.sol";
 import "../../payment/escrow/RefundEscrow.sol";
@@ -14,7 +17,7 @@ import "../../payment/escrow/RefundEscrow.sol";
  * the goal is unlikely to be met, they sell their tokens (possibly at a discount). The attacker will be refunded when
  * the crowdsale is finalized, and the users that purchased from them will be left with worthless tokens.
  */
-contract RefundableCrowdsale is FinalizableCrowdsale {
+contract RefundableCrowdsale is Initializable, Context, FinalizableCrowdsale {
     using SafeMath for uint256;
 
     // minimum amount of funds to be raised in weis
@@ -27,9 +30,16 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
      * @dev Constructor, creates RefundEscrow.
      * @param goal Funding goal
      */
-    constructor (uint256 goal) public {
-        require(goal > 0, "RefundableCrowdsale: goal is 0");
-        _escrow = new RefundEscrow(wallet());
+    function initialize(uint256 goal) public initializer {
+        // FinalizableCrowdsale depends on TimedCrowdsale
+        assert(TimedCrowdsale._hasBeenInitialized());
+
+        require(goal > 0);
+        // 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;
     }
 
@@ -41,12 +51,12 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
     }
 
     /**
-     * @dev Investors can claim refunds here if crowdsale is unsuccessful.
+     * @dev Investors can claim refunds here if crowdsale is unsuccessful
      * @param refundee Whose refund will be claimed.
      */
     function claimRefund(address payable refundee) public {
-        require(finalized(), "RefundableCrowdsale: not finalized");
-        require(!goalReached(), "RefundableCrowdsale: goal reached");
+        require(finalized());
+        require(!goalReached());
 
         _escrow.withdraw(refundee);
     }
@@ -60,7 +70,7 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
     }
 
     /**
-     * @dev Escrow finalization task, called when finalize() is called.
+     * @dev escrow finalization task, called when finalize() is called
      */
     function _finalization() internal {
         if (goalReached()) {
@@ -77,6 +87,8 @@ contract RefundableCrowdsale is FinalizableCrowdsale {
      * @dev Overrides Crowdsale fund forwarding, sending funds to escrow.
      */
     function _forwardFunds() internal {
-        _escrow.deposit.value(msg.value)(msg.sender);
+        _escrow.deposit.value(msg.value)(_msgSender());
     }
+
+    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(), "RefundablePostDeliveryCrowdsale: not finalized");
-        require(goalReached(), "RefundablePostDeliveryCrowdsale: goal not reached");
+        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;
 
@@ -18,10 +19,12 @@ contract AllowanceCrowdsale is Crowdsale {
 
     /**
      * @dev Constructor, takes token wallet address.
-     * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale.
+     * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale
      */
-    constructor (address tokenWallet) public {
-        require(tokenWallet != address(0), "AllowanceCrowdsale: token wallet is the zero address");
+    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
@@ -16,9 +17,8 @@ contract MintedCrowdsale is Crowdsale {
      */
     function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
         // Potentially dangerous assumption about the type of the token.
-        require(
-            ERC20Mintable(address(token())).mint(beneficiary, tokenAmount),
-                "MintedCrowdsale: minting failed"
-        );
+        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,10 +21,11 @@ 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 {
-        require(finalRate > 0, "IncreasingPriceCrowdsale: final rate is 0");
-        // solhint-disable-next-line max-line-length
-        require(initialRate > finalRate, "IncreasingPriceCrowdsale: initial rate is not greater than final rate");
+    function initialize(uint256 initialRate, uint256 finalRate) public initializer {
+        assert(TimedCrowdsale._hasBeenInitialized());
+
+        require(finalRate > 0);
+        require(initialRate > finalRate);
         _initialRate = initialRate;
         _finalRate = finalRate;
     }
@@ -33,7 +35,7 @@ contract IncreasingPriceCrowdsale is TimedCrowdsale {
      * all calls to it are a mistake.
      */
     function rate() public view returns (uint256) {
-        revert("IncreasingPriceCrowdsale: rate() called");
+        revert();
     }
 
     /**
@@ -76,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,8 +17,10 @@ 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 {
-        require(cap > 0, "CappedCrowdsale: cap is 0");
+    function initialize(uint256 cap) public initializer {
+        assert(Crowdsale._hasBeenInitialized());
+
+        require(cap > 0);
         _cap = cap;
     }
 
@@ -43,6 +46,8 @@ contract CappedCrowdsale is Crowdsale {
      */
     function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
         super._preValidatePurchase(beneficiary, weiAmount);
-        require(weiRaised().add(weiAmount) <= _cap, "CappedCrowdsale: cap exceeded");
+        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
@@ -48,12 +55,11 @@ contract IndividuallyCappedCrowdsale is Crowdsale, CapperRole {
      */
     function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
         super._preValidatePurchase(beneficiary, weiAmount);
-        // solhint-disable-next-line max-line-length
-        require(_contributions[beneficiary].add(weiAmount) <= _caps[beneficiary], "IndividuallyCappedCrowdsale: beneficiary's cap exceeded");
+        require(_contributions[beneficiary].add(weiAmount) <= _caps[beneficiary]);
     }
 
     /**
-     * @dev Extend parent behavior to update beneficiary contributions.
+     * @dev Extend parent behavior to update beneficiary contributions
      * @param beneficiary Token purchaser
      * @param weiAmount Amount of wei contributed
      */
@@ -61,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,7 +8,7 @@ import "../Crowdsale.sol";
  * @title TimedCrowdsale
  * @dev Crowdsale accepting contributions only within a time frame.
  */
-contract TimedCrowdsale is Crowdsale {
+contract TimedCrowdsale is Initializable, Crowdsale {
     using SafeMath for uint256;
 
     uint256 private _openingTime;
@@ -24,7 +25,7 @@ contract TimedCrowdsale is Crowdsale {
      * @dev Reverts if not in crowdsale time range.
      */
     modifier onlyWhileOpen {
-        require(isOpen(), "TimedCrowdsale: not open");
+        require(isOpen());
         _;
     }
 
@@ -33,11 +34,12 @@ 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, "TimedCrowdsale: opening time is before current time");
-        // solhint-disable-next-line max-line-length
-        require(closingTime > openingTime, "TimedCrowdsale: opening time is not before closing time");
+        require(openingTime >= block.timestamp);
+        require(closingTime > openingTime);
 
         _openingTime = openingTime;
         _closingTime = closingTime;
@@ -74,8 +76,12 @@ 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.
+     * @dev Extend parent behavior requiring to be within contributing period
      * @param beneficiary Token purchaser
      * @param weiAmount Amount of wei contributed
      */
@@ -84,15 +90,16 @@ contract TimedCrowdsale is Crowdsale {
     }
 
     /**
-     * @dev Extend crowdsale.
+     * @dev Extend crowdsale
      * @param newClosingTime Crowdsale closing time
      */
     function _extendTime(uint256 newClosingTime) internal {
-        require(!hasClosed(), "TimedCrowdsale: already closed");
-        // solhint-disable-next-line max-line-length
-        require(newClosingTime > _closingTime, "TimedCrowdsale: new closing time is before current closing time");
+        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,7 +7,13 @@ import "../../access/roles/WhitelistedRole.sol";
  * @title WhitelistCrowdsale
  * @dev Crowdsale in which only whitelisted users can contribute.
  */
-contract WhitelistCrowdsale is WhitelistedRole, Crowdsale {
+contract WhitelistCrowdsale is Initializable, WhitelistedRole, Crowdsale {
+    function initialize(address sender) public initializer {
+        WhitelistedRole.initialize(sender);
+
+        assert(Crowdsale._hasBeenInitialized());
+    }
+
     /**
      * @dev Extend parent behavior requiring beneficiary to be whitelisted. Note that no
      * restriction is imposed on the account sending the transaction.
@@ -15,7 +21,9 @@ contract WhitelistCrowdsale is WhitelistedRole, Crowdsale {
      * @param _weiAmount Amount of wei contributed
      */
     function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view {
-        require(isWhitelisted(_beneficiary), "WhitelistCrowdsale: beneficiary doesn't have the Whitelisted role");
+        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
@@ -9,7 +9,7 @@ pragma solidity ^0.5.0;
 
 library ECDSA {
     /**
-     * @dev Recover signer address from a message by using their signature.
+     * @dev Recover signer address from a message by using their signature
      * @param hash bytes32 message, the hash is the signed message. What is recovered is the signer address.
      * @param signature bytes signature, the signature is generated using web3.eth.sign()
      */
@@ -56,8 +56,8 @@ library ECDSA {
 
     /**
      * toEthSignedMessageHash
-     * @dev Prefix a bytes32 value with "\x19Ethereum Signed Message:"
-     * and hash the result.
+     * @dev prefix a bytes32 value with "\x19Ethereum Signed Message:"
+     * and hash the result
      */
     function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
         // 32 is the length in bytes of hash,

contracts/cryptography/MerkleProof.sol

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

contracts/drafts/Counters.sol

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

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

contracts/drafts/ERC1820Implementer.sol

@@ -1,24 +0,0 @@
-pragma solidity ^0.5.0;
-
-import "./IERC1820Implementer.sol";
-
-/**
- * @dev ERC1820Implementer allows your contract to implement an interface for another account in the sense of ERC1820.
- * That account or one of its ERC1820 managers can register the implementer in the ERC1820 registry, but the registry
- * will first check with the implementer if it agrees to it, and only allow it if it does. Using the internal
- * function _registerInterfaceForAddress provided by this contract, you are expressing this agreement,
- * and you will be able to register the contract as an implementer in the registry for that account.
- */
-contract ERC1820Implementer is IERC1820Implementer {
-    bytes32 constant private ERC1820_ACCEPT_MAGIC = keccak256(abi.encodePacked("ERC1820_ACCEPT_MAGIC"));
-
-    mapping(bytes32 => mapping(address => bool)) private _supportedInterfaces;
-
-    function canImplementInterfaceForAddress(bytes32 interfaceHash, address account) external view returns (bytes32) {
-        return _supportedInterfaces[interfaceHash][account] ? ERC1820_ACCEPT_MAGIC : bytes32(0x00);
-    }
-
-    function _registerInterfaceForAddress(bytes32 interfaceHash, address account) internal {
-        _supportedInterfaces[interfaceHash][account] = true;
-    }
-}

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";
@@ -21,9 +22,9 @@ import "../math/Math.sol";
  * is migrated, and remain there forever.
  * Although this contract can be used in many different scenarios, the main
  * motivation was to provide a way to migrate ERC20 tokens into an upgradeable
- * version of it using ZeppelinOS. To read more about how this can be done
+ * version of it using the OpenZeppelin SDK. To read more about how this can be done
  * using this implementation, please follow the official documentation site of
- * ZeppelinOS: https://docs.zeppelinos.org/docs/erc20_onboarding.html
+ * the OpenZeppelinSDK: https://docs.zeppelinos.org/docs/erc20_onboarding.html
  * Example of usage:
  * ```
  * const migrator = await ERC20Migrator.new(legacyToken.address);
@@ -31,7 +32,7 @@ import "../math/Math.sol";
  * await migrator.beginMigration(newToken.address);
  * ```
  */
-contract ERC20Migrator {
+contract ERC20Migrator is Initializable {
     using SafeERC20 for IERC20;
 
     /// Address of the old token contract
@@ -43,8 +44,8 @@ contract ERC20Migrator {
     /**
      * @param legacyToken address of the old token contract
      */
-    constructor (IERC20 legacyToken) public {
-        require(address(legacyToken) != address(0), "ERC20Migrator: legacy token is the zero address");
+    function initialize(IERC20 legacyToken) public initializer {
+        require(address(legacyToken) != address(0));
         _legacyToken = legacyToken;
     }
 
@@ -68,10 +69,9 @@ contract ERC20Migrator {
      * @param newToken_ the token that will be minted
      */
     function beginMigration(ERC20Mintable newToken_) public {
-        require(address(_newToken) == address(0), "ERC20Migrator: migration already started");
-        require(address(newToken_) != address(0), "ERC20Migrator: new token is the zero address");
-        //solhint-disable-next-line max-line-length
-        require(newToken_.isMinter(address(this)), "ERC20Migrator: not a minter for new token");
+        require(address(_newToken) == address(0));
+        require(address(newToken_) != address(0));
+        require(newToken_.isMinter(address(this)));
 
         _newToken = newToken_;
     }
@@ -83,7 +83,7 @@ contract ERC20Migrator {
      * @param amount amount of tokens to be migrated
      */
     function migrate(address account, uint256 amount) public {
-        require(address(_newToken) != address(0), "ERC20Migrator: migration not started");
+        require(address(_newToken) != address(0));
         _legacyToken.safeTransferFrom(account, address(this), amount);
         _newToken.mint(account, amount);
     }
@@ -99,4 +99,6 @@ contract ERC20Migrator {
         uint256 amount = Math.min(balance, allowance);
         migrate(account, amount);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC20Snapshot.sol

@@ -1,5 +1,6 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
 import "../math/SafeMath.sol";
 import "../utils/Arrays.sol";
 import "../drafts/Counters.sol";
@@ -18,7 +19,7 @@ import "../token/ERC20/ERC20.sol";
  * account address.
  * @author Validity Labs AG <info@validitylabs.org>
  */
-contract ERC20Snapshot is ERC20 {
+contract ERC20Snapshot is Initializable, ERC20 {
     using SafeMath for uint256;
     using Arrays for uint256[];
     using Counters for Counters.Counter;
@@ -31,7 +32,7 @@ contract ERC20Snapshot is ERC20 {
     }
 
     mapping (address => Snapshots) private _accountBalanceSnapshots;
-    Snapshots private _totalSupplySnapshots;
+    Snapshots private _totalSupplySnaphots;
 
     // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
     Counters.Counter private _currentSnapshotId;
@@ -56,7 +57,7 @@ contract ERC20Snapshot is ERC20 {
     }
 
     function totalSupplyAt(uint256 snapshotId) public view returns(uint256) {
-        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);
+        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnaphots);
 
         return snapshotted ? value : totalSupply();
     }
@@ -101,9 +102,8 @@ contract ERC20Snapshot is ERC20 {
     function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
         private view returns (bool, uint256)
     {
-        require(snapshotId > 0, "ERC20Snapshot: id is 0");
-        // solhint-disable-next-line max-line-length
-        require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");
+        require(snapshotId > 0);
+        require(snapshotId <= _currentSnapshotId.current());
 
         uint256 index = snapshots.ids.findUpperBound(snapshotId);
 
@@ -119,7 +119,7 @@ contract ERC20Snapshot is ERC20 {
     }
 
     function _updateTotalSupplySnapshot() private {
-        _updateSnapshot(_totalSupplySnapshots, totalSupply());
+        _updateSnapshot(_totalSupplySnaphots, totalSupply());
     }
 
     function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
@@ -137,4 +137,6 @@ contract ERC20Snapshot is ERC20 {
             return ids[ids.length - 1];
         }
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/ERC777/ERC777.sol

@@ -1,357 +0,0 @@
-pragma solidity ^0.5.0;
-
-import "./IERC777.sol";
-import "./IERC777Recipient.sol";
-import "./IERC777Sender.sol";
-import "../../math/SafeMath.sol";
-import "../../utils/Address.sol";
-import "../IERC1820Registry.sol";
-
-/**
- * @title ERC777 token implementation
- * @author etsvigun <utgarda@gmail.com>, Bertrand Masius <github@catageeks.tk>
- */
-contract ERC777 is IERC777 {
-    using SafeMath for uint256;
-    using Address for address;
-
-    IERC1820Registry private _erc1820 = IERC1820Registry(0x1820a4B7618BdE71Dce8cdc73aAB6C95905faD24);
-
-    string private _name;
-
-    string private _symbol;
-
-    mapping(address => uint256) private _balances;
-
-    uint256 private _totalSupply;
-
-    uint256 private _granularity;
-
-    bytes32 constant private TOKENS_SENDER_INTERFACE_HASH = keccak256("ERC777TokensSender");
-    bytes32 constant private TOKENS_RECIPIENT_INTERFACE_HASH = keccak256("ERC777TokensRecipient");
-
-    // This isn't ever read from - it's only used to respond to the defaultOperators query.
-    address[] private _defaultOperatorsArray;
-
-    // Immutable, but accounts may revoke them (tracked in __revokedDefaultOperators).
-    mapping(address => bool) private _defaultOperators;
-
-    // For each account, a mapping of its operators and revoked default operators.
-    mapping(address => mapping(address => bool)) private _operators;
-    mapping(address => mapping(address => bool)) private _revokedDefaultOperators;
-
-    constructor(
-        string memory name,
-        string memory symbol,
-        uint256 granularity,
-        address[] memory defaultOperators
-    ) public {
-        require(granularity > 0);
-
-        _name = name;
-        _symbol = symbol;
-        _granularity = granularity;
-
-        _defaultOperatorsArray = defaultOperators;
-        for (uint256 i = 0; i < _defaultOperatorsArray.length; i++) {
-            _defaultOperators[_defaultOperatorsArray[i]] = true;
-        }
-
-        // register interface
-        _erc1820.setInterfaceImplementer(address(this), keccak256("ERC777Token"), address(this));
-    }
-
-    /**
-     * @dev Send the amount of tokens from the address msg.sender to the address to
-     * @param to address recipient address
-     * @param amount uint256 amount of tokens to transfer
-     * @param data bytes information attached to the send, and intended for the recipient (to)
-     */
-    function send(address to, uint256 amount, bytes calldata data) external {
-        _send(msg.sender, msg.sender, to, amount, data, "");
-    }
-
-    /**
-     * @dev Send the amount of tokens on behalf of the address from to the address to
-     * @param from address token holder address.
-     * @param to address recipient address
-     * @param amount uint256 amount of tokens to transfer
-     * @param data bytes information attached to the send, and intended for the recipient (to)
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function operatorSend(
-        address from,
-        address to,
-        uint256 amount,
-        bytes calldata data,
-        bytes calldata operatorData
-    )
-    external
-    {
-        require(isOperatorFor(msg.sender, from));
-        _send(msg.sender, from, to, amount, data, operatorData);
-    }
-
-    /**
-     * @dev Burn the amount of tokens from the address msg.sender
-     * @param amount uint256 amount of tokens to transfer
-     * @param data bytes extra information provided by the token holder
-     */
-    function burn(uint256 amount, bytes calldata data) external {
-        _burn(msg.sender, msg.sender, amount, data, "");
-    }
-
-    /**
-     * @dev Burn the amount of tokens on behalf of the address from
-     * @param from address token holder address.
-     * @param amount uint256 amount of tokens to transfer
-     * @param data bytes extra information provided by the token holder
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function operatorBurn(address from, uint256 amount, bytes calldata data, bytes calldata operatorData) external {
-        require(isOperatorFor(msg.sender, from));
-        _burn(msg.sender, from, amount, data, operatorData);
-    }
-
-    /**
-     * @dev Authorize an operator for the sender
-     * @param operator address to be authorized as operator
-     */
-    function authorizeOperator(address operator) external {
-        require(msg.sender != operator);
-
-        if (_defaultOperators[operator]) {
-            delete _revokedDefaultOperators[msg.sender][operator];
-        } else {
-            _operators[msg.sender][operator] = true;
-        }
-
-        emit AuthorizedOperator(operator, msg.sender);
-    }
-
-    /**
-     * @dev Revoke operator rights from one of the default operators
-     * @param operator address to revoke operator rights from
-     */
-    function revokeOperator(address operator) external {
-        require(operator != msg.sender);
-
-        if (_defaultOperators[operator]) {
-            _revokedDefaultOperators[msg.sender][operator] = true;
-        } else {
-            delete _operators[msg.sender][operator];
-        }
-
-        emit RevokedOperator(operator, msg.sender);
-    }
-
-    /**
-     * @return the name of the token.
-     */
-    function name() public view returns (string memory) {
-        return _name;
-    }
-
-    /**
-     * @return the symbol of the token.
-     */
-    function symbol() public view returns (string memory) {
-        return _symbol;
-    }
-
-    /**
-     * @dev Total number of tokens in existence
-     */
-    function totalSupply() public view returns (uint256) {
-        return _totalSupply;
-    }
-
-    /**
-     * @dev Gets the balance of the specified address.
-     * @param tokenHolder The address to query the balance of.
-        * @return uint256 representing the amount owned by the specified address.
-     */
-    function balanceOf(address tokenHolder) public view returns (uint256) {
-        return _balances[tokenHolder];
-    }
-
-    /**
-     * @dev Gets the token's granularity,
-     * i.e. the smallest number of tokens (in the basic unit)
-     * which may be minted, sent or burned at any time
-     * @return uint256 granularity
-     */
-    function granularity() public view returns (uint256) {
-        return _granularity;
-    }
-
-    /**
-     * @dev Get the list of default operators as defined by the token contract.
-     * @return address[] default operators
-     */
-    function defaultOperators() public view returns (address[] memory) {
-        return _defaultOperatorsArray;
-    }
-
-    /**
-     * @dev Indicate whether an address
-     * is an operator of the tokenHolder address
-     * @param operator address which may be an operator of tokenHolder
-     * @param tokenHolder address of a token holder which may have the operator
-     * address as an operator.
-     */
-    function isOperatorFor(
-        address operator,
-        address tokenHolder
-    ) public view returns (bool) {
-        return operator == tokenHolder ||
-            (_defaultOperators[operator] && !_revokedDefaultOperators[tokenHolder][operator]) ||
-            _operators[tokenHolder][operator];
-    }
-
-    /**
-     * @dev Mint tokens. Does not check authorization of operator
-     * @dev the caller may ckeck that operator is authorized before calling
-     * @param operator address operator requesting the operation
-     * @param to address token recipient address
-     * @param amount uint256 amount of tokens to mint
-     * @param userData bytes extra information defined by the token recipient (if any)
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function _mint(
-        address operator,
-        address to,
-        uint256 amount,
-        bytes memory userData,
-        bytes memory operatorData
-    )
-    internal
-    {
-        require(to != address(0));
-        require((amount % _granularity) == 0);
-
-        // Update state variables
-        _totalSupply = _totalSupply.add(amount);
-        _balances[to] = _balances[to].add(amount);
-
-        _callTokensReceived(operator, address(0), to, amount, userData, operatorData);
-
-        emit Minted(operator, to, amount, userData, operatorData);
-    }
-
-    /**
-     * @dev Send tokens
-     * @param operator address operator requesting the transfer
-     * @param from address token holder address
-     * @param to address recipient address
-     * @param amount uint256 amount of tokens to transfer
-     * @param userData bytes extra information provided by the token holder (if any)
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function _send(
-        address operator,
-        address from,
-        address to,
-        uint256 amount,
-        bytes memory userData,
-        bytes memory operatorData
-    )
-    private
-    {
-        require(from != address(0));
-        require(to != address(0));
-        require((amount % _granularity) == 0);
-
-        _callTokensToSend(operator, from, to, amount, userData, operatorData);
-
-        // Update state variables
-        _balances[from] = _balances[from].sub(amount);
-        _balances[to] = _balances[to].add(amount);
-
-        _callTokensReceived(operator, from, to, amount, userData, operatorData);
-
-        emit Sent(operator, from, to, amount, userData, operatorData);
-    }
-
-    /**
-     * @dev Burn tokens
-     * @param operator address operator requesting the operation
-     * @param from address token holder address
-     * @param amount uint256 amount of tokens to burn
-     * @param data bytes extra information provided by the token holder
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function _burn(
-        address operator,
-        address from,
-        uint256 amount,
-        bytes memory data,
-        bytes memory operatorData
-    )
-    private
-    {
-        require(from != address(0));
-        require((amount % _granularity) == 0);
-
-        _callTokensToSend(operator, from, address(0), amount, data, operatorData);
-
-        // Update state variables
-        _totalSupply = _totalSupply.sub(amount);
-        _balances[from] = _balances[from].sub(amount);
-
-        emit Burned(operator, from, amount, data, operatorData);
-    }
-
-    /**
-     * @dev Call from.tokensToSend() if the interface is registered
-     * @param operator address operator requesting the transfer
-     * @param from address token holder address
-     * @param to address recipient address
-     * @param amount uint256 amount of tokens to transfer
-     * @param userData bytes extra information provided by the token holder (if any)
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function _callTokensToSend(
-        address operator,
-        address from,
-        address to,
-        uint256 amount,
-        bytes memory userData,
-        bytes memory operatorData
-    )
-    private
-    {
-        address implementer = _erc1820.getInterfaceImplementer(from, TOKENS_SENDER_INTERFACE_HASH);
-        if (implementer != address(0)) {
-            IERC777Sender(implementer).tokensToSend(operator, from, to, amount, userData, operatorData);
-        }
-    }
-
-    /**
-     * @dev Call to.tokensReceived() if the interface is registered. Reverts if the recipient is a contract but
-     * tokensReceived() was not registered for the recipient
-     * @param operator address operator requesting the transfer
-     * @param from address token holder address
-     * @param to address recipient address
-     * @param amount uint256 amount of tokens to transfer
-     * @param userData bytes extra information provided by the token holder (if any)
-     * @param operatorData bytes extra information provided by the operator (if any)
-     */
-    function _callTokensReceived(
-        address operator,
-        address from,
-        address to,
-        uint256 amount,
-        bytes memory userData,
-        bytes memory operatorData
-    )
-    private
-    {
-        address implementer = _erc1820.getInterfaceImplementer(to, TOKENS_RECIPIENT_INTERFACE_HASH);
-        if (implementer != address(0)) {
-            IERC777Recipient(implementer).tokensReceived(operator, from, to, amount, userData, operatorData);
-        } else {
-            require(!to.isContract());
-        }
-    }
-}

contracts/drafts/ERC777/IERC777.sol

@@ -1,61 +0,0 @@
-pragma solidity ^0.5.0;
-
-/**
- * @title ERC777 token interface
- * @dev See https://eips.ethereum.org/EIPS/eip-777
- */
-interface IERC777 {
-    function authorizeOperator(address operator) external;
-
-    function revokeOperator(address operator) external;
-
-    function send(address to, uint256 amount, bytes calldata data) external;
-
-    function operatorSend(
-        address from,
-        address to,
-        uint256 amount,
-        bytes calldata data,
-        bytes calldata operatorData
-    ) external;
-
-    function burn(uint256 amount, bytes calldata data) external;
-
-    function operatorBurn(
-        address from,
-        uint256 amount,
-        bytes calldata data,
-        bytes calldata operatorData
-    ) external;
-
-    function name() external view returns (string memory);
-
-    function symbol() external view returns (string memory);
-
-    function totalSupply() external view returns (uint256);
-
-    function balanceOf(address owner) external view returns (uint256);
-
-    function granularity() external view returns (uint256);
-
-    function defaultOperators() external view returns (address[] memory);
-
-    function isOperatorFor(address operator, address tokenHolder) external view returns (bool);
-
-    event Sent(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256 amount,
-        bytes data,
-        bytes operatorData
-    );
-
-    event Minted(address indexed operator, address indexed to, uint256 amount, bytes data, bytes operatorData);
-
-    event Burned(address indexed operator, address indexed from, uint256 amount, bytes data, bytes operatorData);
-
-    event AuthorizedOperator(address indexed operator, address indexed tokenHolder);
-
-    event RevokedOperator(address indexed operator, address indexed tokenHolder);
-}

contracts/drafts/ERC777/IERC777Recipient.sol

@@ -1,16 +0,0 @@
-pragma solidity ^0.5.0;
-
-/**
- * @title ERC777 token recipient interface
- * @dev See https://eips.ethereum.org/EIPS/eip-777
- */
-interface IERC777Recipient {
-    function tokensReceived(
-        address operator,
-        address from,
-        address to,
-        uint amount,
-        bytes calldata userData,
-        bytes calldata operatorData
-    ) external;
-}

contracts/drafts/ERC777/IERC777Sender.sol

@@ -1,16 +0,0 @@
-pragma solidity ^0.5.0;
-
-/**
- * @title ERC777 token sender interface
- * @dev See https://eips.ethereum.org/EIPS/eip-777
- */
-interface IERC777Sender {
-    function tokensToSend(
-        address operator,
-        address from,
-        address to,
-        uint amount,
-        bytes calldata userData,
-        bytes calldata operatorData
-    ) external;
-}

contracts/drafts/IERC1820Implementer.sol

@@ -1,17 +0,0 @@
-pragma solidity ^0.5.0;
-
-/**
- * @title IERC1820Implementer
- * Interface for contracts that will be registered as implementers in the ERC1820 registry.
- * @notice For more details, see https://eips.ethereum.org/EIPS/eip-1820
- */
-interface IERC1820Implementer {
-    /**
-     * @notice Indicates whether the contract implements the interface `interfaceHash` for the address `account` or
-     * not.
-     * @param interfaceHash keccak256 hash of the name of the interface
-     * @param account Address for which the contract will implement the interface
-     * @return ERC1820_ACCEPT_MAGIC only if the contract implements `interfaceHash` for the address `account`.
-     */
-    function canImplementInterfaceForAddress(bytes32 interfaceHash, address account) external view returns (bytes32);
-}

contracts/drafts/IERC1820Registry.sol

@@ -1,90 +0,0 @@
-pragma solidity ^0.5.0;
-
-/**
- * @title ERC1820 Pseudo-introspection Registry Contract
- * @author Jordi Baylina and Jacques Dafflon
- * @notice For more details, see https://eips.ethereum.org/EIPS/eip-1820
- */
-interface IERC1820Registry {
-    /**
-     * @notice Sets the contract which implements a specific interface for an address.
-     * Only the manager defined for that address can set it.
-     * (Each address is the manager for itself until it sets a new manager.)
-     * @param account Address for which to set the interface.
-     * (If 'account' is the zero address then 'msg.sender' is assumed.)
-     * @param interfaceHash Keccak256 hash of the name of the interface as a string.
-     * E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
-     * @param implementer Contract address implementing `interfaceHash` for `account.address()`.
-     */
-    function setInterfaceImplementer(address account, bytes32 interfaceHash, address implementer) external;
-
-    /**
-     * @notice Sets `newManager.address()` as manager for `account.address()`.
-     * The new manager will be able to call 'setInterfaceImplementer' for `account.address()`.
-     * @param account Address for which to set the new manager.
-     * @param newManager Address of the new manager for `addr.address()`.
-     * (Pass '0x0' to reset the manager to `account.address()`.)
-     */
-    function setManager(address account, address newManager) external;
-
-    /**
-     *  @notice Updates the cache with whether the contract implements an ERC165 interface or not.
-     *  @param account Address of the contract for which to update the cache.
-     *  @param interfaceId ERC165 interface for which to update the cache.
-     */
-    function updateERC165Cache(address account, bytes4 interfaceId) external;
-
-    /**
-     *  @notice Get the manager of an address.
-     *  @param account Address for which to return the manager.
-     *  @return Address of the manager for a given address.
-     */
-    function getManager(address account) external view returns (address);
-
-    /**
-     *  @notice Query if an address implements an interface and through which contract.
-     *  @param account Address being queried for the implementer of an interface.
-     *  (If 'account' is the zero address then 'msg.sender' is assumed.)
-     *  @param interfaceHash Keccak256 hash of the name of the interface as a string.
-     *  E.g., 'web3.utils.keccak256("ERC777TokensRecipient")' for the 'ERC777TokensRecipient' interface.
-     *  @return The address of the contract which implements the interface `interfaceHash` for `account.address()`
-     *  or '0' if `account.address()` did not register an implementer for this interface.
-     */
-    function getInterfaceImplementer(address account, bytes32 interfaceHash) external view returns (address);
-
-    /**
-     *  @notice Checks whether a contract implements an ERC165 interface or not.
-     *  If the result is not cached a direct lookup on the contract address is performed.
-     *  If the result is not cached or the cached value is out-of-date, the cache MUST be updated manually by calling
-     *  'updateERC165Cache' with the contract address.
-     *  @param account Address of the contract to check.
-     *  @param interfaceId ERC165 interface to check.
-     *  @return True if `account.address()` implements `interfaceId`, false otherwise.
-     */
-    function implementsERC165Interface(address account, bytes4 interfaceId) external view returns (bool);
-
-    /**
-     *  @notice Checks whether a contract implements an ERC165 interface or not without using nor updating the cache.
-     *  @param account Address of the contract to check.
-     *  @param interfaceId ERC165 interface to check.
-     *  @return True if `account.address()` implements `interfaceId`, false otherwise.
-     */
-    function implementsERC165InterfaceNoCache(address account, bytes4 interfaceId) external view returns (bool);
-
-    /**
-     *  @notice Compute the keccak256 hash of an interface given its name.
-     *  @param interfaceName Name of the interface.
-     *  @return The keccak256 hash of an interface name.
-     */
-    function interfaceHash(string calldata interfaceName) external pure returns (bytes32);
-
-    /**
-     *  @notice Indicates a contract is the `implementer` of `interfaceHash` for `account`.
-     */
-    event InterfaceImplementerSet(address indexed account, bytes32 indexed interfaceHash, address indexed implementer);
-
-    /**
-     *  @notice Indicates `newManager` is the address of the new manager for `account`.
-     */
-    event ManagerChanged(address indexed account, address indexed newManager);
-}

contracts/drafts/SignatureBouncer.sol

@@ -1,5 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../GSN/Context.sol";
 import "../access/roles/SignerRole.sol";
 import "../cryptography/ECDSA.sol";
 
@@ -34,7 +37,7 @@ import "../cryptography/ECDSA.sol";
  * the data in the signature much more complex.
  * See https://ethereum.stackexchange.com/a/50616 for more details.
  */
-contract SignatureBouncer is SignerRole {
+contract SignatureBouncer is Initializable, Context, SignerRole {
     using ECDSA for bytes32;
 
     // Function selectors are 4 bytes long, as documented in
@@ -43,33 +46,33 @@ 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);
     }
 
     /**
-     * @dev Requires that a valid signature of a signer was provided.
+     * @dev requires that a valid signature of a signer was provided
      */
     modifier onlyValidSignature(bytes memory signature) {
-        require(_isValidSignature(msg.sender, signature), "SignatureBouncer: invalid signature for caller");
+        require(_isValidSignature(_msgSender(), signature), "SignatureBouncer: invalid signature for caller");
         _;
     }
 
     /**
-     * @dev Requires that a valid signature with a specified 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) {
         // solhint-disable-next-line max-line-length
-        require(_isValidSignatureAndMethod(msg.sender, signature), "SignatureBouncer: invalid signature for caller and method");
+        require(_isValidSignatureAndMethod(_msgSender(), signature), "SignatureBouncer: invalid signature for caller and method");
         _;
     }
 
     /**
-     * @dev Requires that a valid signature with a specified 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) {
         // solhint-disable-next-line max-line-length
-        require(_isValidSignatureAndData(msg.sender, signature), "SignatureBouncer: invalid signature for caller and data");
+        require(_isValidSignatureAndData(_msgSender(), signature), "SignatureBouncer: invalid signature for caller and data");
         _;
     }
 
@@ -86,9 +89,10 @@ contract SignatureBouncer is SignerRole {
      * @return bool
      */
     function _isValidSignatureAndMethod(address account, bytes memory signature) internal view returns (bool) {
+        bytes memory msgData = _msgData();
         bytes memory data = new bytes(_METHOD_ID_SIZE);
-        for (uint i = 0; i < data.length; i++) {
-            data[i] = msg.data[i];
+        for (uint256 i = 0; i < data.length; i++) {
+            data[i] = msgData[i];
         }
         return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
     }
@@ -99,19 +103,20 @@ contract SignatureBouncer is SignerRole {
      * @return bool
      */
     function _isValidSignatureAndData(address account, bytes memory signature) internal view returns (bool) {
-        require(msg.data.length > _SIGNATURE_SIZE, "SignatureBouncer: data is too short");
+        bytes memory msgData = _msgData();
+        require(msgData.length > _SIGNATURE_SIZE, "SignatureBouncer: data is too short");
 
-        bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
-        for (uint i = 0; i < data.length; i++) {
-            data[i] = msg.data[i];
+        bytes memory data = new bytes(msgData.length - _SIGNATURE_SIZE);
+        for (uint256 i = 0; i < data.length; i++) {
+            data[i] = msgData[i];
         }
 
         return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
     }
 
     /**
-     * @dev Internal function to convert a hash to an eth signed message
-     * and then recover the signature and check it against the signer role.
+     * @dev internal function to convert a hash to an eth signed message
+     * and then recover the signature and check it against the signer role
      * @return bool
      */
     function _isValidDataHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
@@ -119,4 +124,6 @@ contract SignatureBouncer is SignerRole {
 
         return signer != address(0) && isSigner(signer);
     }
+
+    uint256[50] private ______gap;
 }

contracts/drafts/SignedSafeMath.sol

@@ -1,8 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title SignedSafeMath
- * @dev Signed math operations with safety checks that revert on error.
+ * @dev Signed math operations with safety checks that revert on error
  */
 library SignedSafeMath {
     int256 constant private INT256_MIN = -2**255;
@@ -18,10 +18,10 @@ library SignedSafeMath {
             return 0;
         }
 
-        require(!(a == -1 && b == INT256_MIN), "SignedSafeMath: multiplication overflow");
+        require(!(a == -1 && b == INT256_MIN)); // This is the only case of overflow not detected by the check below
 
         int256 c = a * b;
-        require(c / a == b, "SignedSafeMath: multiplication overflow");
+        require(c / a == b);
 
         return c;
     }
@@ -30,8 +30,8 @@ library SignedSafeMath {
      * @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, "SignedSafeMath: division by zero");
-        require(!(b == -1 && a == INT256_MIN), "SignedSafeMath: division overflow");
+        require(b != 0); // Solidity only automatically asserts when dividing by 0
+        require(!(b == -1 && a == INT256_MIN)); // This is the only case of overflow
 
         int256 c = a / b;
 
@@ -43,7 +43,7 @@ library SignedSafeMath {
      */
     function sub(int256 a, int256 b) internal pure returns (int256) {
         int256 c = a - b;
-        require((b >= 0 && c <= a) || (b < 0 && c > a), "SignedSafeMath: subtraction overflow");
+        require((b >= 0 && c <= a) || (b < 0 && c > a));
 
         return c;
     }
@@ -53,7 +53,7 @@ library SignedSafeMath {
      */
     function add(int256 a, int256 b) internal pure returns (int256) {
         int256 c = a + b;
-        require((b >= 0 && c >= a) || (b < 0 && c < a), "SignedSafeMath: addition overflow");
+        require((b >= 0 && c >= a) || (b < 0 && c < a));
 
         return c;
     }

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,7 +11,7 @@ import "../math/SafeMath.sol";
  * typical vesting scheme, with a cliff and vesting period. Optionally revocable by the
  * owner.
  */
-contract TokenVesting is Ownable {
+contract TokenVesting is Initializable, Ownable {
     // The vesting schedule is time-based (i.e. using block timestamps as opposed to e.g. block numbers), and is
     // therefore sensitive to timestamp manipulation (which is something miners can do, to a certain degree). Therefore,
     // it is recommended to avoid using short time durations (less than a minute). Typical vesting schemes, with a
@@ -46,13 +47,13 @@ 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 {
-        require(beneficiary != address(0), "TokenVesting: beneficiary is the zero address");
-        // solhint-disable-next-line max-line-length
-        require(cliffDuration <= duration, "TokenVesting: cliff is longer than duration");
-        require(duration > 0, "TokenVesting: duration is 0");
-        // solhint-disable-next-line max-line-length
-        require(start.add(duration) > block.timestamp, "TokenVesting: final time is before current time");
+    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);
+        require(start.add(duration) > block.timestamp);
 
         _beneficiary = beneficiary;
         _revocable = revocable;
@@ -117,7 +118,7 @@ contract TokenVesting is Ownable {
     function release(IERC20 token) public {
         uint256 unreleased = _releasableAmount(token);
 
-        require(unreleased > 0, "TokenVesting: no tokens are due");
+        require(unreleased > 0);
 
         _released[address(token)] = _released[address(token)].add(unreleased);
 
@@ -132,8 +133,8 @@ contract TokenVesting is Ownable {
      * @param token ERC20 token which is being vested
      */
     function revoke(IERC20 token) public onlyOwner {
-        require(_revocable, "TokenVesting: cannot revoke");
-        require(!_revoked[address(token)], "TokenVesting: token already revoked");
+        require(_revocable);
+        require(!_revoked[address(token)]);
 
         uint256 balance = token.balanceOf(address(this));
 
@@ -171,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, "SampleCrowdSale: goal is greater than cap");
+        require(goal <= cap);
     }
+
+    uint256[50] private ______gap;
 }

contracts/examples/SimpleToken.sol

@@ -1,5 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../GSN/Context.sol";
 import "../token/ERC20/ERC20.sol";
 import "../token/ERC20/ERC20Detailed.sol";
 
@@ -9,14 +12,15 @@ 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 {
-    uint8 public constant DECIMALS = 18;
-    uint256 public constant INITIAL_SUPPLY = 10000 * (10 ** uint256(DECIMALS));
+contract SimpleToken is Initializable, Context,  ERC20, ERC20Detailed {
 
     /**
-     * @dev Constructor that gives msg.sender all of existing tokens.
+     * @dev Constructor that gives _msgSender() 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", 18);
+        _mint(sender, 10000 * (10 ** uint256(decimals())));
     }
+
+    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,37 +8,40 @@ import "./IERC165.sol";
  * @author Matt Condon (@shrugs)
  * @dev Implements ERC165 using a lookup table.
  */
-contract ERC165 is IERC165 {
-    /*
-     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
-     */
+contract ERC165 is Initializable, IERC165 {
     bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
+    /*
+     * 0x01ffc9a7 ===
+     *     bytes4(keccak256('supportsInterface(bytes4)'))
+     */
 
     /**
-     * @dev Mapping of interface ids to whether or not it's supported.
+     * @dev a mapping of interface id to whether or not it's supported
      */
     mapping(bytes4 => bool) private _supportedInterfaces;
 
     /**
      * @dev A contract implementing SupportsInterfaceWithLookup
-     * implements ERC165 itself.
+     * implement ERC165 itself
      */
-    constructor () internal {
+    function initialize() public initializer {
         _registerInterface(_INTERFACE_ID_ERC165);
     }
 
     /**
-     * @dev Implement supportsInterface(bytes4) using a lookup table.
+     * @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];
     }
 
     /**
-     * @dev Internal method for registering an interface.
+     * @dev internal method for registering an interface
      */
     function _registerInterface(bytes4 interfaceId) internal {
-        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
+        require(interfaceId != 0xffffffff);
         _supportedInterfaces[interfaceId] = true;
     }
+
+    uint256[50] private ______gap;
 }

contracts/introspection/ERC165Checker.sol

@@ -1,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title ERC165Checker
@@ -9,10 +9,11 @@ library ERC165Checker {
     // As per the EIP-165 spec, no interface should ever match 0xffffffff
     bytes4 private constant _INTERFACE_ID_INVALID = 0xffffffff;
 
-    /*
-     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
-     */
     bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
+    /*
+     * 0x01ffc9a7 ===
+     *     bytes4(keccak256('supportsInterface(bytes4)'))
+     */
 
     /**
      * @notice Query if a contract supports ERC165

contracts/introspection/IERC165.sol

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

contracts/lifecycle/Pausable.sol

@@ -1,23 +1,28 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+
+import "../GSN/Context.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, Context, 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;
     }
 
     /**
-     * @return True if the contract is paused, false otherwise.
+     * @return true if the contract is paused, false otherwise.
      */
     function paused() public view returns (bool) {
         return _paused;
@@ -27,7 +32,7 @@ contract Pausable is PauserRole {
      * @dev Modifier to make a function callable only when the contract is not paused.
      */
     modifier whenNotPaused() {
-        require(!_paused, "Pausable: paused");
+        require(!_paused);
         _;
     }
 
@@ -35,23 +40,25 @@ contract Pausable is PauserRole {
      * @dev Modifier to make a function callable only when the contract is paused.
      */
     modifier whenPaused() {
-        require(_paused, "Pausable: not paused");
+        require(_paused);
         _;
     }
 
     /**
-     * @dev Called by a pauser to pause, triggers stopped state.
+     * @dev called by the owner to pause, triggers stopped state
      */
     function pause() public onlyPauser whenNotPaused {
         _paused = true;
-        emit Paused(msg.sender);
+        emit Paused(_msgSender());
     }
 
     /**
-     * @dev Called by a pauser to unpause, returns to normal state.
+     * @dev called by the owner to unpause, returns to normal state
      */
     function unpause() public onlyPauser whenPaused {
         _paused = false;
-        emit Unpaused(msg.sender);
+        emit Unpaused(_msgSender());
     }
+
+    uint256[50] private ______gap;
 }

contracts/math/Math.sol

@@ -1,8 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title Math
- * @dev Assorted math operations.
+ * @dev Assorted math operations
  */
 library Math {
     /**

contracts/math/SafeMath.sol

@@ -1,8 +1,8 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 /**
  * @title SafeMath
- * @dev Unsigned math operations with safety checks that revert on error.
+ * @dev Unsigned math operations with safety checks that revert on error
  */
 library SafeMath {
     /**
@@ -17,7 +17,7 @@ library SafeMath {
         }
 
         uint256 c = a * b;
-        require(c / a == b, "SafeMath: multiplication overflow");
+        require(c / a == b);
 
         return c;
     }
@@ -27,7 +27,7 @@ library SafeMath {
      */
     function div(uint256 a, uint256 b) internal pure returns (uint256) {
         // Solidity only automatically asserts when dividing by 0
-        require(b > 0, "SafeMath: division by zero");
+        require(b > 0);
         uint256 c = a / b;
         // assert(a == b * c + a % b); // There is no case in which this doesn't hold
 
@@ -38,7 +38,7 @@ library SafeMath {
      * @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, "SafeMath: subtraction overflow");
+        require(b <= a);
         uint256 c = a - b;
 
         return c;
@@ -49,7 +49,7 @@ library SafeMath {
      */
     function add(uint256 a, uint256 b) internal pure returns (uint256) {
         uint256 c = a + b;
-        require(c >= a, "SafeMath: addition overflow");
+        require(c >= a);
 
         return c;
     }
@@ -59,7 +59,7 @@ library SafeMath {
      * reverts when dividing by zero.
      */
     function mod(uint256 a, uint256 b) internal pure returns (uint256) {
-        require(b != 0, "SafeMath: modulo by zero");
+        require(b != 0);
         return a % b;
     }
 }

contracts/mocks/Acknowledger.sol

@@ -0,0 +1,19 @@
+pragma solidity ^0.5.2;
+
+contract Acknowledger {
+    event AcknowledgeFoo(uint256 a);
+    event AcknowledgeBarSingle(uint256 a);
+    event AcknowledgeBarDouble(uint256 a, uint256 b);
+
+    function foo(uint256 a) public {
+        emit AcknowledgeFoo(a);
+    }
+
+    function bar(uint256 a) public {
+        emit AcknowledgeBarSingle(a);
+    }
+
+    function bar(uint256 a, uint256 b) public {
+        emit AcknowledgeBarDouble(a, b);
+    }
+}

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(_msgSender());
+    }
+
     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(_msgSender());
+    }
+
     function setAllowed(address payee, bool allowed) public {
         _allowed[payee] = allowed;
     }

contracts/mocks/ContextMock.sol

@@ -0,0 +1,27 @@
+pragma solidity ^0.5.0;
+
+import "../GSN/Context.sol";
+
+contract ContextMock is Context {
+    event Sender(address sender);
+
+    function msgSender() public {
+        emit Sender(_msgSender());
+    }
+
+    event Data(bytes data, uint256 integerValue, string stringValue);
+
+    function msgData(uint256 integerValue, string memory stringValue) public {
+        emit Data(_msgData(), integerValue, stringValue);
+    }
+}
+
+contract ContextMockCaller {
+    function callSender(ContextMock context) public {
+        context.msgSender();
+    }
+
+    function callData(ContextMock context, uint256 integerValue, string memory stringValue) public {
+        context.msgData(integerValue, stringValue);
+    }
+}

contracts/mocks/CountersImpl.sol

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

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,4 +1,4 @@
-pragma solidity ^0.5.0;
+pragma solidity ^0.5.2;
 
 import "../../introspection/IERC165.sol";
 
@@ -13,36 +13,37 @@ import "../../introspection/IERC165.sol";
  * solidity-coverage ignores the /mocks folder, so we duplicate its implementation here to avoid instrumenting it
  */
 contract SupportsInterfaceWithLookupMock is IERC165 {
-    /*
-     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
-     */
     bytes4 public constant INTERFACE_ID_ERC165 = 0x01ffc9a7;
+    /*
+     * 0x01ffc9a7 ===
+     *     bytes4(keccak256('supportsInterface(bytes4)'))
+     */
 
     /**
-     * @dev A mapping of interface id to whether or not it's supported.
+     * @dev a mapping of interface id to whether or not it's supported
      */
     mapping(bytes4 => bool) private _supportedInterfaces;
 
     /**
      * @dev A contract implementing SupportsInterfaceWithLookup
-     * implement ERC165 itself.
+     * implement ERC165 itself
      */
     constructor () public {
         _registerInterface(INTERFACE_ID_ERC165);
     }
 
     /**
-     * @dev Implement supportsInterface(bytes4) using a lookup table.
+     * @dev implement supportsInterface(bytes4) using a lookup table
      */
     function supportsInterface(bytes4 interfaceId) external view returns (bool) {
         return _supportedInterfaces[interfaceId];
     }
 
     /**
-     * @dev Private method for registering an interface.
+     * @dev private method for registering an interface
      */
     function _registerInterface(bytes4 interfaceId) internal {
-        require(interfaceId != 0xffffffff, "ERC165InterfacesSupported: invalid interface id");
+        require(interfaceId != 0xffffffff);
         _supportedInterfaces[interfaceId] = true;
     }
 }

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

@@ -1,9 +0,0 @@
-pragma solidity ^0.5.0;
-
-import "../drafts/ERC1820Implementer.sol";
-
-contract ERC1820ImplementerMock is ERC1820Implementer {
-    function registerInterfaceForAddress(bytes32 interfaceHash, address account) public {
-        _registerInterfaceForAddress(interfaceHash, account);
-    }
-}

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, _msgSender());
+    }
+
+}

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

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

contracts/mocks/ERC20MigratorMock.sol

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

contracts/mocks/ERC20MintableMock.sol

@@ -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(_msgSender());
+    }
 }

contracts/mocks/ERC20Mock.sol

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

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(_msgSender());
         _mint(initialAccount, initialBalance);
     }
 }

contracts/mocks/ERC20SnapshotMock.sol

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

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(_msgSender());
+        ERC721MetadataMintable.initialize(_msgSender());
     }
 
     function exists(uint256 tokenId) public view returns (bool) {

contracts/mocks/ERC721GSNRecipientMock.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.5.2;
+
+import "../token/ERC721/ERC721.sol";
+import "../GSN/GSNRecipient.sol";
+import "../GSN/bouncers/GSNBouncerSignature.sol";
+
+/**
+ * @title ERC721GSNRecipientMock
+ * A simple ERC721 mock that has GSN support enabled
+ */
+contract ERC721GSNRecipientMock is ERC721, GSNRecipient, GSNBouncerSignature {
+    constructor(address trustedSigner) public {
+        ERC721.initialize();
+        GSNRecipient.initialize();
+        GSNBouncerSignature.initialize(trustedSigner);
+    }
+
+    function mint(uint256 tokenId) public {
+        _mint(_msgSender(), tokenId);
+    }
+}

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(_msgSender());
+        ERC721MetadataMintable.initialize(_msgSender());
     }
 }

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(_msgSender());
+    }
+
     function mint(address to, uint256 tokenId) public {
         super._mint(to, tokenId);
     }