v2.2.2

* GSN support

Add base Context contract

Add GSNContext and tests

Add RelayHub deployment to tests

Add RelayProvider integration, complete GSNContext tests

Switch dependency to openzeppelin-gsn-provider

Add default txfee to provider

Add basic signing recipient

Sign more values

Add comment clarifying RelayHub's msg.data

Make context constructors internal

Rename SigningRecipient to GSNRecipientSignedData

Add ERC20Charge recipients

Harcode RelayHub address into GSNContext

Fix Solidity linter errors

Run server from binary, use gsn-helpers to fund it

Migrate to published @openzeppelin/gsn-helpers

Silence false-positive compiler warning

Use GSN helper assertions

Rename meta-tx to gsn, take out of drafts

Merge ERC20 charge recipients into a single one

Rename GSNRecipients to Bouncers

Add GSNBouncerUtils to decouple the bouncers from GSNRecipient

Add _upgradeRelayHub

Store RelayHub address using unstructored storage

Add IRelayHub

Add _withdrawDeposits to GSNRecipient

Add relayHub version to recipient

Make _acceptRelayedCall and _declineRelayedCall easier to use

Rename GSNBouncerUtils to GSNBouncerBase, make it IRelayRecipient

Improve GSNBouncerBase, make pre and post sender-protected and optional

Fix GSNBouncerERC20Fee, add tests

Add missing GSNBouncerSignature test

Override transferFrom in __unstable__ERC20PrimaryAdmin

Rhub address slot reduced by 1

Rename relay hub changed event

Use released gsn-provider

* move gsn to all caps

* update to gsn contracts in solidity/master

* Adapt for ethereum-package

* update gsn related packages

* update dependencies to match contracts repo

* remove mocha bail option

* add changelog entry

* add constructors to mocks

* use unstructured storage for bouncer implementations

.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

.gitignore

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

.openzeppelin/kovan.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "PaymentSplitter": {
+      "address": "0x6CE7dEca802e0c5c133f7cbbE719B1da305A6Ae5",
+      "constructorCode": "608060405234801561001057600080fd5b50610be3806100206000396000f3fe",
+      "bodyBytecodeHash": "6f1453b45140bc5e426ffccfcae058daa1fc53439580e3c9e6b7f73aac54c5d8",
+      "localBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "deployedBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9541,
+          "type": "t_uint256",
+          "src": "555:28:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9543,
+          "type": "t_uint256",
+          "src": "589:30:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9547,
+          "type": "t_mapping<t_uint256>",
+          "src": "626:43:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9551,
+          "type": "t_mapping<t_uint256>",
+          "src": "675:45:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9554,
+          "type": "t_array:dyn<t_address>",
+          "src": "726:25:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9800,
+          "type": "t_array:50<t_uint256>",
+          "src": "3251:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0x65e22dDa13EFa3A7fadd3EF62afC815110748308",
+      "constructorCode": "608060405234801561001057600080fd5b5061290d806100206000396000f3fe",
+      "bodyBytecodeHash": "fffcccf2a7439f83b3eb59e01f5217ea14764c782fde08c6edd511f0c7d1e742",
+      "localBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "deployedBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10735,
+          "type": "t_string",
+          "src": "397:20:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10737,
+          "type": "t_string",
+          "src": "423:22:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10739,
+          "type": "t_uint8",
+          "src": "451:23:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10791,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:128"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10239,
+          "type": "t_mapping<t_uint256>",
+          "src": "767:46:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowed",
+          "astId": 10245,
+          "type": "t_mapping<t_uint256>",
+          "src": "820:66:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10247,
+          "type": "t_uint256",
+          "src": "893:28:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10612,
+          "type": "t_array:50<t_uint256>",
+          "src": "7729:29:125"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10840,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:129"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 10963,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:130"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 9135,
+              "type": "t_mapping<t_uint256>",
+              "src": "1410:69:115"
+            }
+          }
+        ]
+      }
+    },
+    "TokenVesting": {
+      "address": "0x94CeBcF32a18eA573C85293883f7D3352b360ec1",
+      "constructorCode": "608060405234801561001057600080fd5b506114d8806100206000396000f3fe",
+      "bodyBytecodeHash": "7a623cf584a99e031f19436c354675c6b43934b0d3705ffc3353558b1fb39496",
+      "localBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "deployedBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9325,
+          "type": "t_address",
+          "src": "317:22:118"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9436,
+          "type": "t_array:50<t_uint256>",
+          "src": "2277:29:118"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4658,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4660,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4662,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4664,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4666,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4670,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4674,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5016,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0xB1a160cD691cF3754AA4AE91ba6e2E18798CcE36",
+      "constructorCode": "608060405234801561001057600080fd5b506135c8806100206000396000f3fe",
+      "bodyBytecodeHash": "b71f19d62583c08240fd85bec42565407f679b1873d7f6e97295a894c7864e2d",
+      "localBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "deployedBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "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": 3632,
+              "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5191,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5235,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11595,
+          "type": "t_mapping<t_address>",
+          "src": "844:48:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11599,
+          "type": "t_mapping<t_address>",
+          "src": "948:52:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11603,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1058:63:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11609,
+          "type": "t_mapping<t_bool>",
+          "src": "1176:73:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12132,
+          "type": "t_array:50<t_uint256>",
+          "src": "11673:29:135"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12183,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "460:50:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12187,
+          "type": "t_mapping<t_uint256>",
+          "src": "580:53:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12190,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "694:28:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12194,
+          "type": "t_mapping<t_uint256>",
+          "src": "793:51:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12523,
+          "type": "t_array:50<t_uint256>",
+          "src": "8816:29:137"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12590,
+          "type": "t_string",
+          "src": "281:20:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12592,
+          "type": "t_string",
+          "src": "328:22:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12596,
+          "type": "t_mapping<t_string>",
+          "src": "396:45:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12725,
+          "type": "t_array:50<t_uint256>",
+          "src": "2849:29:140"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12795,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:141"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 12940,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:143"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11603,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1058:63:135"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0xf5829D56998ccC1405B7eAbCCAC78164AF270D39"
+  },
+  "package": {
+    "address": "0xB6F8F11b166D526932ee04ffe4D25B810f619E34"
+  },
+  "provider": {
+    "address": "0x6290189B262fe198A51e3a3ac06A09c4782D3bD3"
+  },
+  "version": "2.2.2"
+}

.openzeppelin/mainnet.json

@@ -0,0 +1,882 @@
+{
+  "contracts": {
+    "PaymentSplitter": {
+      "address": "0xc6FBEe275DC5a4e7c6bc94bEd156fe10ee09eAba",
+      "constructorCode": "608060405234801561001057600080fd5b50610be3806100206000396000f3fe",
+      "bodyBytecodeHash": "6f1453b45140bc5e426ffccfcae058daa1fc53439580e3c9e6b7f73aac54c5d8",
+      "localBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "deployedBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9541,
+          "type": "t_uint256",
+          "src": "555:28:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9543,
+          "type": "t_uint256",
+          "src": "589:30:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9547,
+          "type": "t_mapping<t_uint256>",
+          "src": "626:43:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9551,
+          "type": "t_mapping<t_uint256>",
+          "src": "675:45:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9554,
+          "type": "t_array:dyn<t_address>",
+          "src": "726:25:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9800,
+          "type": "t_array:50<t_uint256>",
+          "src": "3251:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "TokenVesting": {
+      "address": "0x0E0C247759F066cCbd299dFADe853EdA8D2F3205",
+      "constructorCode": "608060405234801561001057600080fd5b506114d8806100206000396000f3fe",
+      "bodyBytecodeHash": "7a623cf584a99e031f19436c354675c6b43934b0d3705ffc3353558b1fb39496",
+      "localBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "deployedBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9325,
+          "type": "t_address",
+          "src": "317:22:118"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9436,
+          "type": "t_array:50<t_uint256>",
+          "src": "2277:29:118"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4658,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4660,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4662,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4664,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4666,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4670,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4674,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5016,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0xf9D147d5ECfd57EF817EF75B4a329f4fFbb4f100",
+      "constructorCode": "608060405234801561001057600080fd5b506135c8806100206000396000f3fe",
+      "bodyBytecodeHash": "b71f19d62583c08240fd85bec42565407f679b1873d7f6e97295a894c7864e2d",
+      "localBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "deployedBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "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": 3632,
+              "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5191,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5235,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11595,
+          "type": "t_mapping<t_address>",
+          "src": "844:48:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11599,
+          "type": "t_mapping<t_address>",
+          "src": "948:52:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11603,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1058:63:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11609,
+          "type": "t_mapping<t_bool>",
+          "src": "1176:73:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12132,
+          "type": "t_array:50<t_uint256>",
+          "src": "11673:29:135"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12183,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "460:50:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12187,
+          "type": "t_mapping<t_uint256>",
+          "src": "580:53:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12190,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "694:28:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12194,
+          "type": "t_mapping<t_uint256>",
+          "src": "793:51:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12523,
+          "type": "t_array:50<t_uint256>",
+          "src": "8816:29:137"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12590,
+          "type": "t_string",
+          "src": "281:20:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12592,
+          "type": "t_string",
+          "src": "328:22:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12596,
+          "type": "t_mapping<t_string>",
+          "src": "396:45:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12725,
+          "type": "t_array:50<t_uint256>",
+          "src": "2849:29:140"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12795,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:141"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 12940,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:143"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11603,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1058:63:135"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0x2dD5AD2ab73E0cD7E7A05c63aD7D40deD284B69A",
+      "constructorCode": "608060405234801561001057600080fd5b5061290d806100206000396000f3fe",
+      "bodyBytecodeHash": "fffcccf2a7439f83b3eb59e01f5217ea14764c782fde08c6edd511f0c7d1e742",
+      "localBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "deployedBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10735,
+          "type": "t_string",
+          "src": "397:20:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10737,
+          "type": "t_string",
+          "src": "423:22:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10739,
+          "type": "t_uint8",
+          "src": "451:23:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10791,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:128"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10239,
+          "type": "t_mapping<t_uint256>",
+          "src": "767:46:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowed",
+          "astId": 10245,
+          "type": "t_mapping<t_uint256>",
+          "src": "820:66:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10247,
+          "type": "t_uint256",
+          "src": "893:28:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10612,
+          "type": "t_array:50<t_uint256>",
+          "src": "7729:29:125"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10840,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:129"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 10963,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:130"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x2Ba1a8C7352a5B5Ea3ea3408F89e1bA7920d36CE"
+  },
+  "package": {
+    "address": "0x778dddF23Ec1B5Cb18394c6C110480CaaDB3B0f6"
+  },
+  "provider": {
+    "address": "0xd49C0d11A4a7E49c64d954261570FD2d1589f5d2"
+  },
+  "version": "2.2.2"
+}

.openzeppelin/project.json

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

.openzeppelin/rinkeby.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "PaymentSplitter": {
+      "address": "0x83aa4099354E7A315939f4c2E06927175e7C649c",
+      "constructorCode": "608060405234801561001057600080fd5b50610be3806100206000396000f3fe",
+      "bodyBytecodeHash": "6f1453b45140bc5e426ffccfcae058daa1fc53439580e3c9e6b7f73aac54c5d8",
+      "localBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "deployedBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9541,
+          "type": "t_uint256",
+          "src": "555:28:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9543,
+          "type": "t_uint256",
+          "src": "589:30:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9547,
+          "type": "t_mapping<t_uint256>",
+          "src": "626:43:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9551,
+          "type": "t_mapping<t_uint256>",
+          "src": "675:45:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9554,
+          "type": "t_array:dyn<t_address>",
+          "src": "726:25:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9800,
+          "type": "t_array:50<t_uint256>",
+          "src": "3251:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0x55855896e5c5407562b3FE1c1Bb7Bf332aFfDa94",
+      "constructorCode": "608060405234801561001057600080fd5b5061290d806100206000396000f3fe",
+      "bodyBytecodeHash": "fffcccf2a7439f83b3eb59e01f5217ea14764c782fde08c6edd511f0c7d1e742",
+      "localBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "deployedBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10735,
+          "type": "t_string",
+          "src": "397:20:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10737,
+          "type": "t_string",
+          "src": "423:22:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10739,
+          "type": "t_uint8",
+          "src": "451:23:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10791,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:128"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10239,
+          "type": "t_mapping<t_uint256>",
+          "src": "767:46:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowed",
+          "astId": 10245,
+          "type": "t_mapping<t_uint256>",
+          "src": "820:66:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10247,
+          "type": "t_uint256",
+          "src": "893:28:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10612,
+          "type": "t_array:50<t_uint256>",
+          "src": "7729:29:125"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10840,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:129"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 10963,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:130"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 9135,
+              "type": "t_mapping<t_uint256>",
+              "src": "1410:69:115"
+            }
+          }
+        ]
+      }
+    },
+    "TokenVesting": {
+      "address": "0x5B22A5512831ce01269BAbCA8174318f59408435",
+      "constructorCode": "608060405234801561001057600080fd5b506114d8806100206000396000f3fe",
+      "bodyBytecodeHash": "7a623cf584a99e031f19436c354675c6b43934b0d3705ffc3353558b1fb39496",
+      "localBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "deployedBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9325,
+          "type": "t_address",
+          "src": "317:22:118"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9436,
+          "type": "t_array:50<t_uint256>",
+          "src": "2277:29:118"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4658,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4660,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4662,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4664,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4666,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4670,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4674,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5016,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC721": {
+      "address": "0xfcdA0Ae8c7181521c632550de92B1FB3937D166C",
+      "constructorCode": "608060405234801561001057600080fd5b506135c8806100206000396000f3fe",
+      "bodyBytecodeHash": "b71f19d62583c08240fd85bec42565407f679b1873d7f6e97295a894c7864e2d",
+      "localBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "deployedBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "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": 3632,
+              "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5191,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5235,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11595,
+          "type": "t_mapping<t_address>",
+          "src": "844:48:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11599,
+          "type": "t_mapping<t_address>",
+          "src": "948:52:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11603,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1058:63:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11609,
+          "type": "t_mapping<t_bool>",
+          "src": "1176:73:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12132,
+          "type": "t_array:50<t_uint256>",
+          "src": "11673:29:135"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12183,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "460:50:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12187,
+          "type": "t_mapping<t_uint256>",
+          "src": "580:53:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12190,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "694:28:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12194,
+          "type": "t_mapping<t_uint256>",
+          "src": "793:51:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12523,
+          "type": "t_array:50<t_uint256>",
+          "src": "8816:29:137"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12590,
+          "type": "t_string",
+          "src": "281:20:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12592,
+          "type": "t_string",
+          "src": "328:22:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12596,
+          "type": "t_mapping<t_string>",
+          "src": "396:45:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12725,
+          "type": "t_array:50<t_uint256>",
+          "src": "2849:29:140"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12795,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:141"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 12940,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:143"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11603,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1058:63:135"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x291439E6444dAEc9e47Ae359Aa79FD1811A42679"
+  },
+  "package": {
+    "address": "0xa44bb80b290dE8a465d17B14269dF53CF0B9Bf4f"
+  },
+  "provider": {
+    "address": "0x3629bdF19982A06a7a2Fdfac75aC2dA7F5BC3359"
+  },
+  "version": "2.2.2"
+}

.openzeppelin/ropsten.json

@@ -0,0 +1,923 @@
+{
+  "contracts": {
+    "StandaloneERC721": {
+      "address": "0x55C0f7e0B33d414B5541147CFe04E4F6d0dF3616",
+      "constructorCode": "608060405234801561001057600080fd5b506135c8806100206000396000f3fe",
+      "bodyBytecodeHash": "b71f19d62583c08240fd85bec42565407f679b1873d7f6e97295a894c7864e2d",
+      "localBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "deployedBytecodeHash": "2e71874460f43d0696496418b1abf57ed58ce1dc524044860260dda9d7de7fab",
+      "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": 3632,
+              "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "_supportedInterfaces",
+          "astId": 5191,
+          "type": "t_mapping<t_bool>",
+          "src": "511:52:39"
+        },
+        {
+          "contract": "ERC165",
+          "path": "contracts/introspection/ERC165.sol",
+          "label": "______gap",
+          "astId": 5235,
+          "type": "t_array:50<t_uint256>",
+          "src": "1244:29:39"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenOwner",
+          "astId": 11595,
+          "type": "t_mapping<t_address>",
+          "src": "844:48:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_tokenApprovals",
+          "astId": 11599,
+          "type": "t_mapping<t_address>",
+          "src": "948:52:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_ownedTokensCount",
+          "astId": 11603,
+          "type": "t_mapping<t_struct<Counters.Counter>>",
+          "src": "1058:63:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "_operatorApprovals",
+          "astId": 11609,
+          "type": "t_mapping<t_bool>",
+          "src": "1176:73:135"
+        },
+        {
+          "contract": "ERC721",
+          "path": "contracts/token/ERC721/ERC721.sol",
+          "label": "______gap",
+          "astId": 12132,
+          "type": "t_array:50<t_uint256>",
+          "src": "11673:29:135"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokens",
+          "astId": 12183,
+          "type": "t_mapping<t_array:dyn<t_uint256>>",
+          "src": "460:50:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_ownedTokensIndex",
+          "astId": 12187,
+          "type": "t_mapping<t_uint256>",
+          "src": "580:53:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokens",
+          "astId": 12190,
+          "type": "t_array:dyn<t_uint256>",
+          "src": "694:28:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "_allTokensIndex",
+          "astId": 12194,
+          "type": "t_mapping<t_uint256>",
+          "src": "793:51:137"
+        },
+        {
+          "contract": "ERC721Enumerable",
+          "path": "contracts/token/ERC721/ERC721Enumerable.sol",
+          "label": "______gap",
+          "astId": 12523,
+          "type": "t_array:50<t_uint256>",
+          "src": "8816:29:137"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_name",
+          "astId": 12590,
+          "type": "t_string",
+          "src": "281:20:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_symbol",
+          "astId": 12592,
+          "type": "t_string",
+          "src": "328:22:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "_tokenURIs",
+          "astId": 12596,
+          "type": "t_mapping<t_string>",
+          "src": "396:45:140"
+        },
+        {
+          "contract": "ERC721Metadata",
+          "path": "contracts/token/ERC721/ERC721Metadata.sol",
+          "label": "______gap",
+          "astId": 12725,
+          "type": "t_array:50<t_uint256>",
+          "src": "2849:29:140"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC721MetadataMintable",
+          "path": "contracts/token/ERC721/ERC721MetadataMintable.sol",
+          "label": "______gap",
+          "astId": 12795,
+          "type": "t_array:50<t_uint256>",
+          "src": "1055:29:141"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC721Pausable",
+          "path": "contracts/token/ERC721/ERC721Pausable.sol",
+          "label": "______gap",
+          "astId": 12940,
+          "type": "t_array:50<t_uint256>",
+          "src": "865:29:143"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "ERC721",
+            "path": "contracts/token/ERC721/ERC721.sol",
+            "label": "_ownedTokensCount",
+            "astId": 11603,
+            "type": "t_mapping<t_struct<Counters.Counter>>",
+            "src": "1058:63:135"
+          },
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": []
+      }
+    },
+    "StandaloneERC20": {
+      "address": "0x5224DbE42faAB502612f871FB8f45A26bB0B0C13",
+      "constructorCode": "608060405234801561001057600080fd5b5061290d806100206000396000f3fe",
+      "bodyBytecodeHash": "fffcccf2a7439f83b3eb59e01f5217ea14764c782fde08c6edd511f0c7d1e742",
+      "localBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "deployedBytecodeHash": "be0848d29ef0345b76e9810a67328a1deb1a7b07dd050c9212d3099430cf4222",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_name",
+          "astId": 10735,
+          "type": "t_string",
+          "src": "397:20:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_symbol",
+          "astId": 10737,
+          "type": "t_string",
+          "src": "423:22:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "_decimals",
+          "astId": 10739,
+          "type": "t_uint8",
+          "src": "451:23:128"
+        },
+        {
+          "contract": "ERC20Detailed",
+          "path": "contracts/token/ERC20/ERC20Detailed.sol",
+          "label": "______gap",
+          "astId": 10791,
+          "type": "t_array:50<t_uint256>",
+          "src": "1112:29:128"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_balances",
+          "astId": 10239,
+          "type": "t_mapping<t_uint256>",
+          "src": "767:46:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_allowed",
+          "astId": 10245,
+          "type": "t_mapping<t_uint256>",
+          "src": "820:66:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "_totalSupply",
+          "astId": 10247,
+          "type": "t_uint256",
+          "src": "893:28:125"
+        },
+        {
+          "contract": "ERC20",
+          "path": "contracts/token/ERC20/ERC20.sol",
+          "label": "______gap",
+          "astId": 10612,
+          "type": "t_array:50<t_uint256>",
+          "src": "7729:29:125"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "_minters",
+          "astId": 1448,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:10"
+        },
+        {
+          "contract": "MinterRole",
+          "path": "contracts/access/roles/MinterRole.sol",
+          "label": "______gap",
+          "astId": 1547,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:10"
+        },
+        {
+          "contract": "ERC20Mintable",
+          "path": "contracts/token/ERC20/ERC20Mintable.sol",
+          "label": "______gap",
+          "astId": 10840,
+          "type": "t_array:50<t_uint256>",
+          "src": "760:29:129"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "_pausers",
+          "astId": 1567,
+          "type": "t_struct<Roles.Role>",
+          "src": "286:27:11"
+        },
+        {
+          "contract": "PauserRole",
+          "path": "contracts/access/roles/PauserRole.sol",
+          "label": "______gap",
+          "astId": 1666,
+          "type": "t_array:50<t_uint256>",
+          "src": "1096:29:11"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "_paused",
+          "astId": 5401,
+          "type": "t_bool",
+          "src": "367:20:42"
+        },
+        {
+          "contract": "Pausable",
+          "path": "contracts/lifecycle/Pausable.sol",
+          "label": "______gap",
+          "astId": 5482,
+          "type": "t_array:50<t_uint256>",
+          "src": "1444:29:42"
+        },
+        {
+          "contract": "ERC20Pausable",
+          "path": "contracts/token/ERC20/ERC20Pausable.sol",
+          "label": "______gap",
+          "astId": 10963,
+          "type": "t_array:50<t_uint256>",
+          "src": "1209:29:130"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [
+          {
+            "contract": "MinterRole",
+            "path": "contracts/access/roles/MinterRole.sol",
+            "label": "_minters",
+            "astId": 1448,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:10"
+          },
+          {
+            "contract": "PauserRole",
+            "path": "contracts/access/roles/PauserRole.sol",
+            "label": "_pausers",
+            "astId": 1567,
+            "type": "t_struct<Roles.Role>",
+            "src": "286:27:11"
+          }
+        ],
+        "storageDiff": [
+          {
+            "action": "rename",
+            "updated": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowed",
+              "astId": 10245,
+              "type": "t_mapping<t_uint256>",
+              "src": "820:66:125"
+            },
+            "original": {
+              "index": 8,
+              "contract": "ERC20",
+              "path": "contracts/token/ERC20/ERC20.sol",
+              "label": "_allowances",
+              "astId": 9135,
+              "type": "t_mapping<t_uint256>",
+              "src": "1410:69:115"
+            }
+          }
+        ]
+      }
+    },
+    "TokenVesting": {
+      "address": "0x2c0Ba048b8dd92c8f8c437F584bA0E8C5745C11e",
+      "constructorCode": "608060405234801561001057600080fd5b506114d8806100206000396000f3fe",
+      "bodyBytecodeHash": "7a623cf584a99e031f19436c354675c6b43934b0d3705ffc3353558b1fb39496",
+      "localBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "deployedBytecodeHash": "e1b9a489ba9fe411cb345548cfbdfb8ef0a9a528c48a9bd07a08f5728a432ea3",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "_owner",
+          "astId": 9325,
+          "type": "t_address",
+          "src": "317:22:118"
+        },
+        {
+          "contract": "Ownable",
+          "path": "contracts/ownership/Ownable.sol",
+          "label": "______gap",
+          "astId": 9436,
+          "type": "t_array:50<t_uint256>",
+          "src": "2277:29:118"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_beneficiary",
+          "astId": 4658,
+          "type": "t_address",
+          "src": "1148:28:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_cliff",
+          "astId": 4660,
+          "type": "t_uint256",
+          "src": "1278:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_start",
+          "astId": 4662,
+          "type": "t_uint256",
+          "src": "1306:22:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_duration",
+          "astId": 4664,
+          "type": "t_uint256",
+          "src": "1334:25:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revocable",
+          "astId": 4666,
+          "type": "t_bool",
+          "src": "1366:23:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_released",
+          "astId": 4670,
+          "type": "t_mapping<t_uint256>",
+          "src": "1396:46:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "_revoked",
+          "astId": 4674,
+          "type": "t_mapping<t_bool>",
+          "src": "1448:42:36"
+        },
+        {
+          "contract": "TokenVesting",
+          "path": "contracts/drafts/TokenVesting.sol",
+          "label": "______gap",
+          "astId": 5016,
+          "type": "t_array:50<t_uint256>",
+          "src": "5852:29:36"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    },
+    "PaymentSplitter": {
+      "address": "0xa4988102Dd242B1cF0f50bD6f0D702C08B943Cba",
+      "constructorCode": "608060405234801561001057600080fd5b50610be3806100206000396000f3fe",
+      "bodyBytecodeHash": "6f1453b45140bc5e426ffccfcae058daa1fc53439580e3c9e6b7f73aac54c5d8",
+      "localBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "deployedBytecodeHash": "1b0f3688284b1c14c41ce636762c4504188969cb0e5a052159b61b87cbd4e8a8",
+      "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": 13400,
+          "type": "t_bool",
+          "src": "757:24:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "initializing",
+          "astId": 13402,
+          "type": "t_bool",
+          "src": "876:25:153"
+        },
+        {
+          "contract": "Initializable",
+          "path": "@openzeppelin/upgrades/contracts/Initializable.sol",
+          "label": "______gap",
+          "astId": 13458,
+          "type": "t_array:50<t_uint256>",
+          "src": "1951:29:153"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalShares",
+          "astId": 9541,
+          "type": "t_uint256",
+          "src": "555:28:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_totalReleased",
+          "astId": 9543,
+          "type": "t_uint256",
+          "src": "589:30:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_shares",
+          "astId": 9547,
+          "type": "t_mapping<t_uint256>",
+          "src": "626:43:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_released",
+          "astId": 9551,
+          "type": "t_mapping<t_uint256>",
+          "src": "675:45:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "_payees",
+          "astId": 9554,
+          "type": "t_array:dyn<t_address>",
+          "src": "726:25:120"
+        },
+        {
+          "contract": "PaymentSplitter",
+          "path": "contracts/payment/PaymentSplitter.sol",
+          "label": "______gap",
+          "astId": 9800,
+          "type": "t_array:50<t_uint256>",
+          "src": "3251:29:120"
+        }
+      ],
+      "warnings": {
+        "hasConstructor": false,
+        "hasSelfDestruct": false,
+        "hasDelegateCall": false,
+        "hasInitialValuesInDeclarations": false,
+        "uninitializedBaseContracts": [],
+        "storageUncheckedVars": [],
+        "storageDiff": []
+      }
+    }
+  },
+  "solidityLibs": {},
+  "proxies": {},
+  "manifestVersion": "2.2",
+  "frozen": true,
+  "app": {
+    "address": "0x27a09abCA2c4d9F914dbC7BeA164b0e6b74Ce7a9"
+  },
+  "package": {
+    "address": "0x2a9e7B63514438906A83a1e320dBBD814D417002"
+  },
+  "provider": {
+    "address": "0xdE16eC017431009ebE329E54D399CB4d5e161B8d"
+  },
+  "version": "2.2.2"
+}

.travis.yml

@@ -1,53 +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
-
-    - stage: update docs
-      if: tag =~ ^v[0-9]+\.[0-9]+\.[0-9]+$
-      addons:
-        apt:
-          packages:
-            - curl
-      script:
-        - ./scripts/ci/trigger_docs_update "${TRAVIS_TAG}"
-
-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,5 +1,15 @@
 # Changelog
 
+## 2.2.2 (2019-08-12)
+
+### New features:
+ * Facilities to make metatransaction-enabled contracts through the Gas Station Network. Backported from [#1844](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1844).
+
+## 2.2.1 (2019-07-22)
+
+### Changes:
+* Renamed package to `@openzeppelin/contracts-ethereum-package`. ([#54](https://github.com/OpenZeppelin/openzeppelin-contracts-ethereum-package/pull/54))
+
 ## 2.2.0 (2019-03-14)
 
 ### New features:

README.md

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

contracts/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) initializer public {
+        // 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/roles/CapperRole.sol

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

contracts/access/roles/MinterRole.sol

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

contracts/access/roles/PauserRole.sol

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

contracts/access/roles/SignerRole.sol

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

contracts/access/roles/WhitelistAdminRole.sol

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

contracts/access/roles/WhitelistedRole.sol

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

contracts/crowdsale/Crowdsale.sol

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

contracts/crowdsale/distribution/FinalizableCrowdsale.sol

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

contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol

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

contracts/crowdsale/distribution/RefundableCrowdsale.sol

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

contracts/crowdsale/distribution/RefundablePostDeliveryCrowdsale.sol

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

contracts/crowdsale/emission/AllowanceCrowdsale.sol

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

contracts/crowdsale/emission/MintedCrowdsale.sol

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

contracts/crowdsale/price/IncreasingPriceCrowdsale.sol

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

contracts/crowdsale/validation/CappedCrowdsale.sol

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

contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol

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

contracts/crowdsale/validation/PausableCrowdsale.sol

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

contracts/crowdsale/validation/TimedCrowdsale.sol

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

contracts/crowdsale/validation/WhitelistCrowdsale.sol

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

contracts/drafts/ERC1046/ERC20Metadata.sol

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

contracts/drafts/ERC20Migrator.sol

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

contracts/drafts/ERC20Snapshot.sol

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

contracts/drafts/SignatureBouncer.sol

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

contracts/drafts/TokenVesting.sol

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

contracts/examples/SampleCrowdsale.sol

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

contracts/examples/SimpleToken.sol

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

contracts/introspection/ERC165.sol

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

contracts/lifecycle/Pausable.sol

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

contracts/mocks/AllowanceCrowdsaleImpl.sol

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

contracts/mocks/CappedCrowdsaleImpl.sol

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

contracts/mocks/CapperRoleMock.sol

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

contracts/mocks/ConditionalEscrowMock.sol

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

contracts/mocks/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/CrowdsaleMock.sol

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

contracts/mocks/ERC165Mock.sol

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

contracts/mocks/ERC20BurnableMock.sol

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

contracts/mocks/ERC20CappedMock.sol

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

contracts/mocks/ERC20DetailedMock.sol

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

contracts/mocks/ERC20MetadataMock.sol

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

contracts/mocks/ERC20MigratorMock.sol

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

contracts/mocks/ERC20MintableMock.sol

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

contracts/mocks/ERC20PausableMock.sol

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

contracts/mocks/ERC721FullMock.sol

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

contracts/mocks/ERC721MintableBurnableImpl.sol

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

contracts/mocks/ERC721Mock.sol

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

contracts/mocks/ERC721PausableMock.sol

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

contracts/mocks/EscrowMock.sol

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

contracts/mocks/FinalizableCrowdsaleImpl.sol

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

contracts/mocks/ForceEther.sol

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

contracts/mocks/GSNBouncerERC20FeeMock.sol

@@ -0,0 +1,22 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "../GSN/GSNRecipient.sol";
+import "../GSN/bouncers/GSNBouncerERC20Fee.sol";
+
+contract GSNBouncerERC20FeeMock is GSNRecipient, GSNBouncerERC20Fee {
+    constructor(string memory name, string memory symbol, uint8 decimals) public {
+        GSNBouncerERC20Fee.initialize(name, symbol, decimals);
+        GSNRecipient.initialize();
+    }
+
+    function mint(address account, uint256 amount) public {
+        _mint(account, amount);
+    }
+
+    event MockFunctionCalled(uint256 senderBalance);
+
+    function mockFunction() public {
+        emit MockFunctionCalled(token().balanceOf(_msgSender()));
+    }
+}

contracts/mocks/GSNBouncerSignatureMock.sol

@@ -0,0 +1,18 @@
+pragma solidity ^0.5.0;
+
+import "@openzeppelin/upgrades/contracts/Initializable.sol";
+import "../GSN/GSNRecipient.sol";
+import "../GSN/bouncers/GSNBouncerSignature.sol";
+
+contract GSNBouncerSignatureMock is GSNRecipient, GSNBouncerSignature {
+    constructor(address trustedSigner) public {
+        GSNBouncerSignature.initialize(trustedSigner);
+        GSNRecipient.initialize();
+    }
+
+    event MockFunctionCalled();
+
+    function mockFunction() public {
+        emit MockFunctionCalled();
+    }
+}

contracts/mocks/GSNContextMock.sol

@@ -0,0 +1,50 @@
+pragma solidity ^0.5.0;
+
+import "./ContextMock.sol";
+import "../GSN/GSNContext.sol";
+import "../GSN/IRelayRecipient.sol";
+
+// By inheriting from GSNContext, Context's internal functions are overridden automatically
+contract GSNContextMock is ContextMock, GSNContext, IRelayRecipient {
+    constructor() public {
+        GSNContext.initialize();
+    }
+
+    function getHubAddr() public view returns (address) {
+        return _getRelayHub();
+    }
+
+    function acceptRelayedCall(
+        address,
+        address,
+        bytes calldata,
+        uint256,
+        uint256,
+        uint256,
+        uint256,
+        bytes calldata,
+        uint256
+    )
+        external
+        view
+        returns (uint256, bytes memory)
+    {
+        return (0, "");
+    }
+
+    function preRelayedCall(bytes calldata) external returns (bytes32) {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    function postRelayedCall(bytes calldata, bool, uint256, bytes32) external {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    function getRelayHub() public view returns (address) {
+        return _getRelayHub();
+    }
+
+    function upgradeRelayHub(address newRelayHub) public {
+        return _upgradeRelayHub(newRelayHub);
+    }
+}

contracts/mocks/GSNRecipientMock.sol

@@ -0,0 +1,29 @@
+pragma solidity ^0.5.0;
+
+import "../GSN/GSNRecipient.sol";
+
+contract GSNRecipientMock is GSNRecipient {
+    constructor() public {
+        GSNRecipient.initialize();
+    }
+
+    function withdrawDeposits(uint256 amount, address payable payee) public {
+        _withdrawDeposits(amount, payee);
+    }
+
+    function acceptRelayedCall(address, address, bytes calldata, uint256, uint256, uint256, uint256, bytes calldata, uint256)
+        external
+        view
+        returns (uint256, bytes memory)
+    {
+        return (0, "");
+    }
+
+    function preRelayedCall(bytes calldata) external returns (bytes32) {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    function postRelayedCall(bytes calldata, bool, uint256, bytes32) external {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+}

contracts/mocks/IncreasingPriceCrowdsaleImpl.sol

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

contracts/mocks/IndividuallyCappedCrowdsaleImpl.sol

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

contracts/mocks/MessageHelper.sol

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

contracts/mocks/MintedCrowdsaleImpl.sol

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

contracts/mocks/MinterRoleMock.sol

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

contracts/mocks/OwnableMock.sol

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

contracts/mocks/PausableCrowdsaleImpl.sol

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

contracts/mocks/PausableMock.sol

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

contracts/mocks/PauserRoleMock.sol

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

contracts/mocks/PaymentSplitterMock.sol

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

contracts/mocks/PostDeliveryCrowdsaleImpl.sol

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

contracts/mocks/PullPaymentMock.sol

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

contracts/mocks/ReentrancyMock.sol

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

contracts/mocks/RefundEscrowMock.sol

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

contracts/mocks/RefundableCrowdsaleImpl.sol

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

contracts/mocks/RefundablePostDeliveryCrowdsaleImpl.sol

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

contracts/mocks/SampleCrowdsaleMock.sol

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

contracts/mocks/SecondaryMock.sol

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

contracts/mocks/SignatureBouncerMock.sol

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

contracts/mocks/SignerRoleMock.sol

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

contracts/mocks/SimpleTokenMock.sol

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

contracts/mocks/TimedCrowdsaleImpl.sol

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

contracts/mocks/TokenTimelockMock.sol

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

contracts/mocks/TokenVestingMock.sol

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

contracts/mocks/WhitelistAdminRoleMock.sol

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

contracts/mocks/WhitelistCrowdsaleImpl.sol

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

contracts/mocks/WhitelistedRoleMock.sol

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

contracts/ownership/Ownable.sol

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

contracts/ownership/Secondary.sol

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