Redirect docs.openzeppelin.org to docs root (#2057)

docs.openzeppelin.org was redirecting to the contracts documentation, instead of the documentation landing

.codecov.yml

@@ -1,12 +0,0 @@
-comment: off
-github_checks:
-  annotations: false
-coverage:
-  status:
-    patch:
-      default:
-        target: 95%
-        only_pulls: true
-    project:
-      default:
-        threshold: 1%

.editorconfig

@@ -6,16 +6,7 @@ root = true
 [*]
 charset = utf-8
 end_of_line = lf
+indent_size = 2
 indent_style = space
 insert_final_newline = true
-trim_trailing_whitespace = false
-max_line_length = 120
-
-[*.sol]
-indent_size = 4
-
-[*.js]
-indent_size = 2
-
-[*.{adoc,md}]
-max_line_length = 0
+trim_trailing_whitespace = true

.eslintrc

@@ -1,9 +1,11 @@
 {
   "extends" : [
-    "standard"
+    "standard",
+    "plugin:promise/recommended",
   ],
   "plugins": [
-    "mocha"
+    "mocha-no-only",
+    "promise",
   ],
   "env": {
     "browser" : true,
@@ -16,8 +18,6 @@
     "contract": false,
     "assert": false,
     "web3": false,
-    "usePlugin": false,
-    "extendEnvironment": false,
   },
   "rules": {
 
@@ -25,7 +25,6 @@
     "strict": ["error", "global"],
 
     // Code style
-    "array-bracket-spacing": ["off"],
     "camelcase": ["error", {"properties": "always"}],
     "comma-dangle": ["error", "always-multiline"],
     "comma-spacing": ["error", {"before": false, "after": true}],
@@ -51,12 +50,9 @@
     "semi": ["error", "always"],
     "space-before-function-paren": ["error", "always"],
 
-    "mocha/no-exclusive-tests": ["error"],
+    "mocha-no-only/mocha-no-only": ["error"],
 
     "promise/always-return": "off",
     "promise/avoid-new": "off",
-  },
-  "parserOptions": {
-    "ecmaVersion": 2020
   }
 }

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,16 +1,16 @@
 ---
 name: Bug report
-about: Report a bug in OpenZeppelin Contracts
+about: Report a bug in OpenZeppelin
 
 ---
 
 <!-- Briefly describe the issue you're experiencing. Tell us what you were trying to do and what happened instead. -->
 
-<!-- Remember, this is not a place to ask for help debugging code. For that, we welcome you in the OpenZeppelin Community Forum: https://forum.openzeppelin.com/. -->
+<!-- Remember, this is not a place to ask for help debugging code. For that, we welcome you in the Zeppelin Forum: https://forum.zeppelin.solutions/. -->
 
 **💻 Environment**
 
-<!-- Tell us what version of OpenZeppelin Contracts you're using, and how you're using it: Truffle, Remix, etc. -->
+<!-- Tell us what version of OpenZeppelin you're using, and how you're using it: Truffle, Remix, etc. -->
 
 **📝 Details**
 

.github/ISSUE_TEMPLATE/config.yml

@@ -1,4 +0,0 @@
-contact_links:
-  - name: Questions & Support Requests
-    url: https://forum.openzeppelin.com/c/support/contracts/18
-    about: Ask in the OpenZeppelin Forum

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,6 +1,6 @@
 ---
 name: Feature request
-about: Suggest an idea for OpenZeppelin Contracts
+about: Suggest an idea for OpenZeppelin
 
 ---
 
@@ -10,5 +10,5 @@ about: Suggest an idea for OpenZeppelin Contracts
 **📝 Details**
 <!-- Please describe your feature request in detail. -->
 
-<!-- Make sure that you have reviewed the OpenZeppelin Contracts Contributor Guidelines. -->
-<!-- https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/CONTRIBUTING.md -->
+<!-- Make sure that you have reviewed the OpenZeppelin Contributor Guidelines. -->
+<!-- https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/CONTRIBUTING.md -->

.github/PULL_REQUEST_TEMPLATE.md

@@ -1,20 +1,22 @@
-<!-- Thank you for your interest in contributing to OpenZeppelin! -->
+<!-- 0. 🎉 Thank you for submitting a PR! -->
 
-<!-- Consider opening an issue for discussion prior to submitting a PR. -->
-<!-- New features will be merged faster if they were first discussed and designed with the team. -->
+<!-- 1. Does this close any open issues? Please list them below. -->
 
-Fixes #???? <!-- Fill in with issue number -->
+<!-- Keep in mind that new features have a better chance of being merged fast if
+they were first discussed and designed with the maintainers. If there is no
+corresponding issue, please consider opening one for discussion first! -->
 
-<!-- Describe the changes introduced in this pull request. -->
-<!-- Include any context necessary for understanding the PR's purpose. -->
+Fixes #
 
+<!-- 2. Describe the changes introduced in this pull request. -->
+<!--    Include any context necessary for understanding the PR's purpose. -->
 
-#### PR Checklist
-
-<!-- Before merging the pull request all of the following must be complete. -->
-<!-- Feel free to submit a PR or Draft PR even if some items are pending. -->
-<!-- Some of the items may not apply. -->
-
-- [ ] Tests
-- [ ] Documentation
-- [ ] Changelog entry
+<!-- 3. Before submitting, please make sure that you have:
+  - reviewed the OpenZeppelin Contributor Guidelines
+    (https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/CONTRIBUTING.md),
+  - added tests where applicable to test new functionality,
+  - made sure that your contracts are well-documented,
+  - run the Solidity linter (`npm run lint:sol`) and fixed any issues,
+  - run the JS linter and fixed any issues (`npm run lint:fix`), and
+  - updated the changelog, if applicable.
+-->

.github/actions/gas-compare/action.yml

@@ -1,49 +0,0 @@
-name: Compare gas costs
-inputs:
-  token:
-    description: github token
-    required: true
-  report:
-    description: report to read from
-    required: false
-    default: gasReporterOutput.json
-  out_report:
-    description: report to read
-    required: false
-    default: ${{ github.ref_name }}.gasreport.json
-  ref_report:
-    description: report to read from
-    required: false
-    default: ${{ github.base_ref }}.gasreport.json
-
-runs:
-  using: composite
-  steps:
-    - name: Download reference report
-      if: github.event_name == 'pull_request'
-      run: |
-        RUN_ID=`gh run list --repo ${{ github.repository }} --branch ${{ github.base_ref }} --workflow ${{ github.workflow }} --limit 100 --json 'conclusion,databaseId,event' --jq 'map(select(.conclusion=="success" and .event!="pull_request"))[0].databaseId'`
-        gh run download ${RUN_ID} --repo ${{ github.repository }} -n gasreport
-      env:
-        GITHUB_TOKEN: ${{ inputs.token }}
-      shell: bash
-      continue-on-error: true
-      id: reference
-    - name: Compare reports
-      if: steps.reference.outcome == 'success' && github.event_name == 'pull_request'
-      run: |
-        node scripts/checks/compareGasReports.js ${{ inputs.report }} ${{ inputs.ref_report }} >> $GITHUB_STEP_SUMMARY
-      env:
-        STYLE: markdown
-      shell: bash
-    - name: Rename report for upload
-      if: github.event_name != 'pull_request'
-      run: |
-        mv ${{ inputs.report }} ${{ inputs.out_report }}
-      shell: bash
-    - name: Save report
-      if: github.event_name != 'pull_request'
-      uses: actions/upload-artifact@v3
-      with:
-        name: gasreport
-        path: ${{ inputs.out_report }}

.github/actions/setup/action.yml

@@ -1,20 +0,0 @@
-name: Setup
-
-runs:
-  using: composite
-  steps:
-    - uses: actions/setup-node@v3
-      with:
-        node-version: 14.x
-        cache: npm
-    - uses: actions/cache@v3
-      id: cache
-      with:
-        path: '**/node_modules'
-        key: npm-v3-${{ hashFiles('**/package-lock.json') }}
-    - name: Install dependencies
-      run: npm ci --prefer-offline
-      shell: bash
-      if: steps.cache.outputs.cache-hit != 'true'
-      env:
-        SKIP_COMPILE: true

.github/stale.yml

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

.github/workflows/changelog.yml

@@ -1,28 +0,0 @@
-name: changelog
-
-on:
-  pull_request:
-    types:
-      - opened
-      - synchronize
-      - labeled
-      - unlabeled
-
-concurrency:
-  group: changelog-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    if: ${{ !contains(github.event.pull_request.labels.*.name, 'ignore-changelog') }}
-    steps:
-      - uses: actions/checkout@v3
-      - name: Check diff
-        run: |
-          git fetch origin ${{ github.base_ref }} --depth=1
-          if git diff --exit-code origin/${{ github.base_ref }} -- CHANGELOG.md ; then
-            echo 'Missing changelog entry'
-            exit 1
-          fi
-

.github/workflows/checks.yml

@@ -1,90 +0,0 @@
-name: checks
-
-on:
-  push:
-    branches:
-      - master
-      - release-v*
-  pull_request: {}
-  workflow_dispatch: {}
-
-concurrency:
-  group: checks-${{ github.ref }}
-  cancel-in-progress: true
-
-jobs:
-  lint:
-    if: github.repository != 'OpenZeppelin/openzeppelin-contracts-upgradeable'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - run: npm run lint
-
-  tests:
-    runs-on: ubuntu-latest
-    env:
-      FORCE_COLOR: 1
-      GAS: true
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - name: Run tests and generate gas report
-        run: npm run test
-      - name: Check linearisation of the inheritance graph
-        run: npm run test:inheritance
-      - name: Check proceduraly generated contracts are up-to-date
-        if: github.repository != 'OpenZeppelin/openzeppelin-contracts-upgradeable'
-        run: npm run test:generation
-      - name: Compare gas costs
-        uses: ./.github/actions/gas-compare
-        with:
-          token: ${{ github.token }}
-
-  foundry-tests:
-    if: github.repository != 'OpenZeppelin/openzeppelin-contracts-upgradeable'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: recursive
-      - name: Install Foundry
-        uses: foundry-rs/foundry-toolchain@v1
-        with:
-          version: nightly
-      - name: Run tests
-        run: forge test -vv
-
-  coverage:
-    if: github.repository != 'OpenZeppelin/openzeppelin-contracts-upgradeable'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - run: npm run coverage
-        env:
-          NODE_OPTIONS: --max_old_space_size=4096
-      - uses: codecov/codecov-action@v3
-
-  slither:
-    if: github.repository != 'OpenZeppelin/openzeppelin-contracts-upgradeable'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - uses: crytic/slither-action@v0.1.1
-
-  codespell:
-    if: github.repository != 'OpenZeppelin/openzeppelin-contracts-upgradeable'
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Run CodeSpell
-        uses: codespell-project/actions-codespell@v1.0
-        with:
-          check_filenames: true
-          skip: package-lock.json

.github/workflows/docs.yml

@@ -1,16 +0,0 @@
-name: Build Docs
-
-on:
-  push:
-    branches: [release-v*]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - name: Set up environment
-        uses: ./.github/actions/setup
-      - run: bash scripts/git-user-config.sh
-      - run: node scripts/update-docs-branch.js
-      - run: git push --all origin 

.github/workflows/upgradeable.yml

@@ -1,23 +0,0 @@
-name: Upgradeable Trigger
-
-on:
-  push:
-    branches:
-      - master
-      - release-v*
-
-jobs:
-  trigger:
-    runs-on: ubuntu-latest
-    steps:
-      - id: app
-        uses: getsentry/action-github-app-token@v1
-        with:
-          app_id: ${{ secrets.UPGRADEABLE_APP_ID }}
-          private_key: ${{ secrets.UPGRADEABLE_APP_PK }}
-      - run: |
-          curl -X POST \
-            https://api.github.com/repos/OpenZeppelin/openzeppelin-contracts-upgradeable/dispatches \
-            -H 'Accept: application/vnd.github.v3+json' \
-            -H 'Authorization: token ${{ steps.app.outputs.token }}' \
-            -d '{ "event_type": "Update", "client_payload": { "ref": "${{ github.ref }}" } }'

.gitignore

@@ -41,24 +41,6 @@ build/
 # IntelliJ IDE
 .idea
 
-# docs artifacts
-docs/modules/api
-
-# only used to package @openzeppelin/contracts
-contracts/build/
-contracts/README.md
-
-# temporary artifact from solidity-coverage
-allFiredEvents
-.coverage_artifacts
-.coverage_cache
-.coverage_contracts
-
-# hardhat
-cache
-artifacts
-
-# Certora
-.certora*
-.last_confs
-certora_*
+# docsite artifacts
+docsite-build
+docs/api

.gitmodules

@@ -1,3 +0,0 @@
-[submodule "lib/forge-std"]
-	path = lib/forge-std
-	url = https://github.com/foundry-rs/forge-std

.mocharc.js

@@ -1,4 +0,0 @@
-module.exports = {
-  require: 'hardhat/register',
-  timeout: 4000,
-};

.prettierrc

@@ -1,14 +0,0 @@
-{
-  "singleQuote": true,
-  "trailingComma": "all",
-  "overrides": [
-    {
-      "files": "*.sol",
-      "options": {
-        "singleQuote": false,
-        "printWidth": 120,
-        "explicitTypes": "always"
-      }
-    }
-  ]
-}

.solcover.js

@@ -1,15 +1,9 @@
 module.exports = {
     norpc: true,
-    testCommand: 'npm test',
-    compileCommand: 'npm run compile',
+    testCommand: 'node --max-old-space-size=4096 ../node_modules/.bin/truffle test --network coverage',
+    compileCommand: 'node --max-old-space-size=4096 ../node_modules/.bin/truffle compile --network coverage',
     skipFiles: [
-        'mocks',
-    ],
-    providerOptions: {
-        default_balance_ether: '10000000000000000000000000',
-    },
-    mocha: {
-        fgrep: '[skip-on-coverage]',
-        invert: true,
-    },
+        'lifecycle/Migrations.sol',
+        'mocks'
+    ]
 }

.solhint.json

@@ -1,14 +1,12 @@
 {
+  "extends": "default",
   "rules": {
-    "no-unused-vars": "error",
-    "const-name-snakecase": "error",
-    "contract-name-camelcase": "error",
-    "event-name-camelcase": "error",
-    "func-name-mixedcase": "error",
-    "func-param-name-mixedcase": "error",
-    "modifier-name-mixedcase": "error",
-    "private-vars-leading-underscore": "error",
-    "var-name-mixedcase": "error",
-    "imports-on-top": "error"
+    "indent": ["error", 4],
+    "func-order": false,
+    "bracket-align": false,
+    "compiler-fixed": false,
+    "no-simple-event-func-name": false,
+    "separate-by-one-line-in-contract": false,
+    "two-lines-top-level-separator": false
   }
 }

.travis.yml

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

CHANGELOG.md

@@ -1,567 +1,38 @@
 # Changelog
 
-## 4.8.0 (2022-11-08)
-
- * `TimelockController`: Added a new `admin` constructor parameter that is assigned the admin role instead of the deployer account. ([#3722](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3722))
- * `Initializable`: add internal functions `_getInitializedVersion` and `_isInitializing` ([#3598](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3598))
- * `ERC165Checker`: add `supportsERC165InterfaceUnchecked` for consulting individual interfaces without the full ERC165 protocol. ([#3339](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3339))
- * `Address`: optimize `functionCall` by calling `functionCallWithValue` directly. ([#3468](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3468))
- * `Address`: optimize `functionCall` functions by checking contract size only if there is no returned data. ([#3469](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3469))
- * `Governor`: make the `relay` function payable, and add support for EOA payments. ([#3730](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3730))
- * `GovernorCompatibilityBravo`: remove unused `using` statements. ([#3506](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3506))
- * `ERC20`: optimize `_transfer`, `_mint` and `_burn` by using `unchecked` arithmetic when possible. ([#3513](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3513))
- * `ERC20Votes`, `ERC721Votes`: optimize `getPastVotes` for looking up recent checkpoints. ([#3673](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3673))
- * `ERC20FlashMint`: add an internal `_flashFee` function for overriding. ([#3551](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3551))
- * `ERC4626`: use the same `decimals()` as the underlying asset by default (if available). ([#3639](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3639))
- * `ERC4626`: add internal `_initialConvertToShares` and `_initialConvertToAssets` functions to customize empty vaults behavior. ([#3639](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3639))
- * `ERC721`: optimize transfers by making approval clearing implicit instead of emitting an event. ([#3481](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3481))
- * `ERC721`: optimize burn by making approval clearing implicit instead of emitting an event. ([#3538](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3538))
- * `ERC721`: Fix balance accounting when a custom `_beforeTokenTransfer` hook results in a transfer of the token under consideration. ([#3611](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3611))
- * `ERC721`: use unchecked arithmetic for balance updates. ([#3524](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3524))
- * `ERC721Consecutive`: Implementation of EIP-2309 that allows batch minting of ERC721 tokens during construction. ([#3311](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3311))
- * `ReentrancyGuard`: Reduce code size impact of the modifier by using internal functions. ([#3515](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3515))
- * `SafeCast`: optimize downcasting of signed integers. ([#3565](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3565))
- * `ECDSA`: Remove redundant check on the `v` value. ([#3591](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3591))
- * `VestingWallet`: add `releasable` getters. ([#3580](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3580))
- * `VestingWallet`: remove unused library `Math.sol`. ([#3605](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3605))
- * `VestingWallet`: make constructor payable. ([#3665](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3665))
- * `Create2`: optimize address computation by using assembly instead of `abi.encodePacked`. ([#3600](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3600))
- * `Clones`: optimized the assembly to use only the scratch space during deployments, and optimized `predictDeterministicAddress` to use fewer operations. ([#3640](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3640))
- * `Checkpoints`: Use procedural generation to support multiple key/value lengths. ([#3589](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3589))
- * `Checkpoints`: Add new lookup mechanisms. ([#3589](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3589))
- * `Arrays`: Add `unsafeAccess` functions that allow reading and writing to an element in a storage array bypassing Solidity's "out-of-bounds" check. ([#3589](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3589))
- * `Strings`: optimize `toString`. ([#3573](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3573))
- * `Ownable2Step`: extension of `Ownable` that makes the ownership transfers a two step process. ([#3620](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3620))
- * `Math` and `SignedMath`: optimize function `max` by using `>` instead of `>=`. ([#3679](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3679))
- * `Math`: Add `log2`, `log10` and `log256`. ([#3670](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3670))
- * Arbitrum: Update the vendored arbitrum contracts to match the nitro upgrade. ([#3692](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3692))
-
-### Breaking changes
-
- * `ERC721`: In order to add support for batch minting via `ERC721Consecutive` it was necessary to make a minor breaking change in the internal interface of `ERC721`. Namely, the hooks `_beforeTokenTransfer` and `_afterTokenTransfer` have one additional argument that may need to be added to overrides:
-
-```diff
- function _beforeTokenTransfer(
-     address from,
-     address to,
-     uint256 tokenId,
-+    uint256 batchSize
- ) internal virtual override
-```
-
- * `ERC4626`: Conversion from shares to assets (and vice-versa) in an empty vault used to consider the possible mismatch between the underlying asset's and the vault's decimals. This initial conversion rate is now set to 1-to-1 irrespective of decimals, which are meant for usability purposes only. The vault now uses the assets decimals by default, so off-chain the numbers should appear the same. Developers overriding the vault decimals to a value that does not match the underlying asset may want to override the `_initialConvertToShares` and `_initialConvertToAssets` to replicate the previous behavior.
-
- * `TimelockController`: During deployment, the TimelockController used to grant the `TIMELOCK_ADMIN_ROLE` to the deployer and to the timelock itself. The deployer was then expected to renounce this role once configuration of the timelock is over. Failing to renounce that role allows the deployer to change the timelock permissions (but not to bypass the delay for any time-locked actions). The role is no longer given to the deployer by default. A new parameter `admin` can be set to a non-zero address to grant the admin role during construction (to the deployer or any other address). Just like previously, this admin role should be renounced after configuration. If this param is given `address(0)`, the role is not allocated and doesn't need to be revoked. In any case, the timelock itself continues to have this role.
-
-### Deprecations
-
- * `EIP712`: Added the file `EIP712.sol` and deprecated `draft-EIP712.sol` since the EIP is no longer a Draft. Developers are encouraged to update their imports. ([#3621](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3621))
-
-```diff
--import "@openzeppelin/contracts/utils/cryptography/draft-EIP712.sol";
-+import "@openzeppelin/contracts/utils/cryptography/EIP712.sol";
-```
-
- * `ERC721Votes`: Added the file `ERC721Votes.sol` and deprecated `draft-ERC721Votes.sol` since it no longer depends on a Draft EIP (EIP-712). Developers are encouraged to update their imports. ([#3699](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3699))
-
-```diff
--import "@openzeppelin/contracts/token/ERC721/extensions/draft-ERC721Votes.sol";
-+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Votes.sol";
-```
-
-### ERC-721 Compatibility Note
-
-ERC-721 integrators that interpret contract state from events should make sure that they implement the clearing of approval that is implicit in every transfer according to the EIP. Previous versions of OpenZeppelin Contracts emitted an explicit `Approval` event even though it was not required by the specification, and this is no longer the case.
-
-With the new `ERC721Consecutive` extension, the internal workings of `ERC721` are slightly changed. Custom extensions to ERC721 should be reviewed to ensure they remain correct. The internal functions that should be considered are `_ownerOf` (new), `_beforeTokenTransfer`, and `_afterTokenTransfer`.
-
-## 4.7.3
-
-### Breaking changes
-
- * `ECDSA`: `recover(bytes32,bytes)` and `tryRecover(bytes32,bytes)` no longer accept compact signatures to prevent malleability. Compact signature support remains available using `recover(bytes32,bytes32,bytes32)` and `tryRecover(bytes32,bytes32,bytes32)`.
-
-## 4.7.2
-
- * `LibArbitrumL2`, `CrossChainEnabledArbitrumL2`: Fixed detection of cross-chain calls for EOAs. Previously, calls from EOAs would be classified as cross-chain calls. ([#3578](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3578))
- * `GovernorVotesQuorumFraction`: Fixed quorum updates so they do not affect past proposals that failed due to lack of quorum. ([#3561](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3561))
- * `ERC165Checker`: Added protection against large returndata. ([#3587](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3587))
-
-## 4.7.1
-
- * `SignatureChecker`: Fix an issue that causes `isValidSignatureNow` to revert when the target contract returns ill-encoded data. ([#3552](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3552))
- * `ERC165Checker`: Fix an issue that causes `supportsInterface` to revert when the target contract returns ill-encoded data. ([#3552](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3552))
-
-## 4.7.0 (2022-06-29)
-
- * `TimelockController`: Migrate `_call` to `_execute` and allow inheritance and overriding similar to `Governor`. ([#3317](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3317))
- * `CrossChainEnabledPolygonChild`: replace the `require` statement with the custom error `NotCrossChainCall`. ([#3380](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3380))
- * `ERC20FlashMint`: Add customizable flash fee receiver. ([#3327](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3327))
- * `ERC4626`: add an extension of `ERC20` that implements the ERC4626 Tokenized Vault Standard. ([#3171](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3171))
- * `SafeERC20`: add `safePermit` as mitigation against phantom permit functions. ([#3280](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3280))
- * `Math`: add a `mulDiv` function that can round the result either up or down. ([#3171](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3171))
- * `Math`: Add a `sqrt` function to compute square roots of integers, rounding either up or down. ([#3242](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3242))
- * `Strings`: add a new overloaded function `toHexString` that converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. ([#3403](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3403))
- * `EnumerableMap`: add new `UintToUintMap` map type. ([#3338](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3338))
- * `EnumerableMap`: add new `Bytes32ToUintMap` map type. ([#3416](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3416))
- * `SafeCast`: add support for many more types, using procedural code generation. ([#3245](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3245))
- * `MerkleProof`: add `multiProofVerify` to prove multiple values are part of a Merkle tree. ([#3276](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3276))
- * `MerkleProof`: add calldata versions of the functions to avoid copying input arrays to memory and save gas. ([#3200](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3200))
- * `ERC721`, `ERC1155`: simplified revert reasons. ([#3254](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3254), ([#3438](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3438)))
- * `ERC721`: removed redundant require statement. ([#3434](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3434))
- * `PaymentSplitter`: add `releasable` getters. ([#3350](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3350))
- * `Initializable`: refactored implementation of modifiers for easier understanding. ([#3450](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3450))
- * `Proxies`: remove runtime check of ERC1967 storage slots. ([#3455](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3455))
-
-### Breaking changes
-
- * `Initializable`: functions decorated with the modifier `reinitializer(1)` may no longer invoke each other.
-
-## 4.6.0 (2022-04-26)
-
- * `crosschain`: Add a new set of contracts for cross-chain applications. `CrossChainEnabled` is a base contract with instantiations for several chains and bridges, and `AccessControlCrossChain` is an extension of access control that allows cross-chain operation. ([#3183](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3183))
- * `AccessControl`: add a virtual `_checkRole(bytes32)` function that can be overridden to alter the `onlyRole` modifier behavior. ([#3137](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3137))
- * `EnumerableMap`: add new `AddressToUintMap` map type. ([#3150](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3150))
- * `EnumerableMap`: add new `Bytes32ToBytes32Map` map type. ([#3192](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3192))
- * `ERC20FlashMint`: support infinite allowance when paying back a flash loan. ([#3226](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3226))
- * `ERC20Wrapper`: the `decimals()` function now tries to fetch the value from the underlying token instance. If that calls revert, then the default value is used. ([#3259](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3259))
- * `draft-ERC20Permit`: replace `immutable` with `constant` for `_PERMIT_TYPEHASH` since the `keccak256` of string literals is treated specially and the hash is evaluated at compile time. ([#3196](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3196))
- * `ERC1155`: Add a `_afterTokenTransfer` hook for improved extensibility. ([#3166](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3166))
- * `ERC1155URIStorage`: add a new extension that implements a `_setURI` behavior similar to ERC721's `_setTokenURI`. ([#3210](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3210))
- * `DoubleEndedQueue`: a new data structure that supports efficient push and pop to both front and back, useful for FIFO and LIFO queues. ([#3153](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3153))
- * `Governor`: improved security of `onlyGovernance` modifier when using an external executor contract (e.g. a timelock) that can operate without necessarily going through the governance protocol. ([#3147](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3147))
- * `Governor`: Add a way to parameterize votes. This can be used to implement voting systems such as fractionalized voting, ERC721 based voting, or any number of other systems. The `params` argument added to `_countVote` method, and included in the newly added `_getVotes` method, can be used by counting and voting modules respectively for such purposes. ([#3043](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3043))
- * `Governor`: rewording of revert reason for consistency. ([#3275](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3275))
- * `Governor`: fix an inconsistency in data locations that could lead to invalid bytecode being produced. ([#3295](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3295))
- * `Governor`: Implement `IERC721Receiver` and `IERC1155Receiver` to improve token custody by governors. ([#3230](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3230))
- * `TimelockController`: Implement `IERC721Receiver` and `IERC1155Receiver` to improve token custody by timelocks. ([#3230](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3230))
- * `TimelockController`: Add a separate canceller role for the ability to cancel. ([#3165](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3165))
- * `Initializable`: add a reinitializer modifier that enables the initialization of new modules, added to already initialized contracts through upgradeability. ([#3232](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3232))
- * `Initializable`: add an Initialized event that tracks initialized version numbers. ([#3294](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3294))
- * `ERC2981`: make `royaltyInfo` public to allow super call in overrides. ([#3305](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3305))
-
-### Upgradeability notice
-
-* `TimelockController`: **(Action needed)** The upgrade from <4.6 to >=4.6 introduces a new `CANCELLER_ROLE` that requires set up to be assignable. After the upgrade, only addresses with this role will have the ability to cancel. Proposers will no longer be able to cancel. Assigning cancellers can be done by an admin (including the timelock itself) once the role admin is set up. To do this, we recommend upgrading to the `TimelockControllerWith46MigrationUpgradeable` contract and then calling the `migrateTo46` function.
-
-### Breaking changes
-
-* `Governor`: Adds internal virtual `_getVotes` method that must be implemented; this is a breaking change for existing concrete extensions to `Governor`. To fix this on an existing voting module extension, rename `getVotes` to `_getVotes` and add a `bytes memory` argument. ([#3043](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3043))
-* `Governor`: Adds `params` parameter to internal virtual `_countVote` method; this is a breaking change for existing concrete extensions to `Governor`. To fix this on an existing counting module extension, add a `bytes memory` argument to `_countVote`. ([#3043](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3043))
-* `Governor`: Does not emit `VoteCast` event when params data is non-empty; instead emits `VoteCastWithParams` event. To fix this on an integration that consumes the `VoteCast` event, also fetch/monitor `VoteCastWithParams` events. ([#3043](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3043))
-* `Votes`: The internal virtual function `_getVotingUnits` was made `view` (which was accidentally missing). Any overrides should now be updated so they are `view` as well.
-
-## 4.5.0 (2022-02-09)
-
- * `ERC2981`: add implementation of the royalty standard, and the respective extensions for `ERC721` and `ERC1155`. ([#3012](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3012))
- * `GovernorTimelockControl`: improve the `state()` function to have it reflect cases where a proposal has been canceled directly on the timelock. ([#2977](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2977))
- * Preset contracts are now deprecated in favor of [Contracts Wizard](https://wizard.openzeppelin.com). ([#2986](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2986))
- * `Governor`: add a relay function to help recover assets sent to a governor that is not its own executor (e.g. when using a timelock). ([#2926](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2926))
- * `GovernorPreventLateQuorum`: add new module to ensure a minimum voting duration is available after the quorum is reached. ([#2973](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2973))
- * `ERC721`: improved revert reason when transferring from wrong owner. ([#2975](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2975))
- * `Votes`: Added a base contract for vote tracking with delegation. ([#2944](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2944))
- * `ERC721Votes`: Added an extension of ERC721 enabled with vote tracking and delegation. ([#2944](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2944))
- * `ERC2771Context`: use immutable storage to store the forwarder address, no longer an issue since Solidity >=0.8.8 allows reading immutable variables in the constructor. ([#2917](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2917))
- * `Base64`: add a library to parse bytes into base64 strings using `encode(bytes memory)` function, and provide examples to show how to use to build URL-safe `tokenURIs`. ([#2884](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2884))
- * `ERC20`: reduce allowance before triggering transfer. ([#3056](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3056))
- * `ERC20`: do not update allowance on `transferFrom` when allowance is `type(uint256).max`. ([#3085](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3085))
- * `ERC20`: add a `_spendAllowance` internal function. ([#3170](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3170))
- * `ERC20Burnable`: do not update allowance on `burnFrom` when allowance is `type(uint256).max`. ([#3170](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3170))
- * `ERC777`: do not update allowance on `transferFrom` when allowance is `type(uint256).max`. ([#3085](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3085))
- * `ERC777`: add a `_spendAllowance` internal function. ([#3170](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3170))
- * `SignedMath`: a new signed version of the Math library with `max`, `min`,  and `average`. ([#2686](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2686))
- * `SignedMath`: add an `abs(int256)` method that returns the unsigned absolute value of a signed value. ([#2984](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2984))
- * `ERC1967Upgrade`: Refactor the secure upgrade to use `ERC1822` instead of the previous rollback mechanism. This reduces code complexity and attack surface with similar security guarantees. ([#3021](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3021))
- * `UUPSUpgradeable`: Add `ERC1822` compliance to support the updated secure upgrade mechanism. ([#3021](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3021))
- * Some more functions have been made virtual to customize them via overrides. In many cases this will not imply that other functions in the contract will automatically adapt to the overridden definitions. People who wish to override should consult the source code to understand the impact and if they need to override any additional functions to achieve the desired behavior.
-
-### Breaking changes
-
-* `ERC1967Upgrade`: The function `_upgradeToAndCallSecure` was renamed to `_upgradeToAndCallUUPS`, along with the change in security mechanism described above.
-* `Address`: The Solidity pragma is increased from `^0.8.0` to `^0.8.1`. This is required by the `account.code.length` syntax that replaces inline assembly. This may require users to bump their compiler version from `0.8.0` to `0.8.1` or later. Note that other parts of the code already include stricter requirements.
-
-## 4.4.2 (2022-01-11)
-
-### Bugfixes
- * `GovernorCompatibilityBravo`: Fix error in the encoding of calldata for proposals submitted through the compatibility interface with explicit signatures. ([#3100](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3100))
-
-## 4.4.1 (2021-12-14)
-
- * `Initializable`: change the existing `initializer` modifier and add a new `onlyInitializing` modifier to prevent reentrancy risk. ([#3006](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/3006))
-
-### Breaking change
-
-It is no longer possible to call an `initializer`-protected function from within another `initializer` function outside the context of a constructor. Projects using OpenZeppelin upgradeable proxies should continue to work as is, since in the common case the initializer is invoked in the constructor directly. If this is not the case for you, the suggested change is to use the new `onlyInitializing` modifier in the following way:
-
-```diff
- contract A {
--    function initialize() public   initializer { ... }
-+    function initialize() internal onlyInitializing { ... }
- }
- contract B is A {
-     function initialize() public initializer {
-         A.initialize();
-     }
- }
-```
-
-## 4.4.0 (2021-11-25)
-
- * `Ownable`: add an internal `_transferOwnership(address)`. ([#2568](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2568))
- * `AccessControl`: add internal `_grantRole(bytes32,address)` and `_revokeRole(bytes32,address)`. ([#2568](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2568))
- * `AccessControl`: mark `_setupRole(bytes32,address)` as deprecated in favor of `_grantRole(bytes32,address)`. ([#2568](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2568))
- * `AccessControlEnumerable`: hook into `_grantRole(bytes32,address)` and `_revokeRole(bytes32,address)`. ([#2946](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2946))
- * `EIP712`: cache `address(this)` to immutable storage to avoid potential issues if a vanilla contract is used in a delegatecall context. ([#2852](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2852))
- * Add internal `_setApprovalForAll` to `ERC721` and `ERC1155`. ([#2834](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2834))
- * `Governor`: shift vote start and end by one block to better match Compound's GovernorBravo and prevent voting at the Governor level if the voting snapshot is not ready. ([#2892](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2892))
- * `GovernorCompatibilityBravo`: consider quorum an inclusive rather than exclusive minimum to match Compound's GovernorBravo. ([#2974](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2974))
- * `GovernorSettings`: a new governor module that manages voting settings updatable through governance actions. ([#2904](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2904))
- * `PaymentSplitter`: now supports ERC20 assets in addition to Ether. ([#2858](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2858))
- * `ECDSA`: add a variant of `toEthSignedMessageHash` for arbitrary length message hashing. ([#2865](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2865))
- * `MerkleProof`: add a `processProof` function that returns the rebuilt root hash given a leaf and a proof. ([#2841](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2841))
- * `VestingWallet`: new contract that handles the vesting of Ether and ERC20 tokens following a customizable vesting schedule. ([#2748](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2748))
- * `Governor`: enable receiving Ether when a Timelock contract is not used. ([#2748](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2849))
- * `GovernorTimelockCompound`: fix ability to use Ether stored in the Timelock contract. ([#2748](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2849))
-
-## 4.3.3
-
- * `ERC1155Supply`: Handle `totalSupply` changes by hooking into `_beforeTokenTransfer` to ensure consistency of balances and supply during `IERC1155Receiver.onERC1155Received` calls.
-
-## 4.3.2 (2021-09-14)
-
- * `UUPSUpgradeable`: Add modifiers to prevent `upgradeTo` and `upgradeToAndCall` being executed on any contract that is not the active ERC1967 proxy. This prevents these functions being called on implementation contracts or minimal ERC1167 clones, in particular.
-
-## 4.3.1 (2021-08-26)
-
- * `TimelockController`: Add additional isOperationReady check.
-
-## 4.3.0 (2021-08-17)
-
- * `ERC2771Context`: use private variable from storage to store the forwarder address. Fixes issues where `_msgSender()` was not callable from constructors. ([#2754](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2754))
- * `EnumerableSet`: add `values()` functions that returns an array containing all values in a single call. ([#2768](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2768))
- * `Governor`: added a modular system of `Governor` contracts based on `GovernorAlpha` and `GovernorBravo`. ([#2672](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2672))
- * Add an `interfaces` folder containing solidity interfaces to final ERCs. ([#2517](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2517))
- * `ECDSA`: add `tryRecover` functions that will not throw if the signature is invalid, and will return an error flag instead. ([#2661](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2661))
- * `SignatureChecker`: Reduce gas usage of the `isValidSignatureNow` function for the "signature by EOA" case. ([#2661](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2661))
-
-## 4.2.0 (2021-06-30)
-
- * `ERC20Votes`: add a new extension of the `ERC20` token with support for voting snapshots and delegation. ([#2632](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2632))
- * `ERC20VotesComp`: Variant of `ERC20Votes` that is compatible with Compound's `Comp` token interface but restricts supply to `uint96`. ([#2706](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2706))
- * `ERC20Wrapper`: add a new extension of the `ERC20` token which wraps an underlying token. Deposit and withdraw guarantee that the total supply is backed by a corresponding amount of underlying token. ([#2633](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2633))
- * Enumerables: Improve gas cost of removal in `EnumerableSet` and `EnumerableMap`.
- * Enumerables: Improve gas cost of lookup in `EnumerableSet` and `EnumerableMap`.
- * `Counter`: add a reset method. ([#2678](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2678))
- * Tokens: Wrap definitely safe subtractions in `unchecked` blocks.
- * `Math`: Add a `ceilDiv` method for performing ceiling division.
- * `ERC1155Supply`: add a new `ERC1155` extension that keeps track of the totalSupply of each tokenId. ([#2593](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2593))
- * `BitMaps`: add a new `BitMaps` library that provides a storage efficient datastructure for `uint256` to `bool` mapping with contiguous keys. ([#2710](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2710))
-
-### Breaking Changes
-
- * `ERC20FlashMint` is no longer a Draft ERC. ([#2673](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2673)))
-
-**How to update:** Change your import paths by removing the `draft-` prefix from `@openzeppelin/contracts/token/ERC20/extensions/draft-ERC20FlashMint.sol`.
-
-> See [Releases and Stability: Drafts](https://docs.openzeppelin.com/contracts/4.x/releases-stability#drafts).
-
-## 4.1.0 (2021-04-29)
-
- * `IERC20Metadata`: add a new extended interface that includes the optional `name()`, `symbol()` and `decimals()` functions. ([#2561](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2561))
- * `ERC777`: make reception acquirement optional in `_mint`. ([#2552](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2552))
- * `ERC20Permit`: add a `_useNonce` to enable further usage of ERC712 signatures. ([#2565](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2565))
- * `ERC20FlashMint`: add an implementation of the ERC3156 extension for flash-minting ERC20 tokens. ([#2543](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2543))
- * `SignatureChecker`: add a signature verification library that supports both EOA and ERC1271 compliant contracts as signers. ([#2532](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2532))
- * `Multicall`: add abstract contract with `multicall(bytes[] calldata data)` function to bundle multiple calls together ([#2608](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2608))
- * `ECDSA`: add support for ERC2098 short-signatures. ([#2582](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2582))
- * `AccessControl`: add an `onlyRole` modifier to restrict specific function to callers bearing a specific role. ([#2609](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2609))
- * `StorageSlot`: add a library for reading and writing primitive types to specific storage slots. ([#2542](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2542))
- * UUPS Proxies: add `UUPSUpgradeable` to implement the UUPS proxy pattern together with `EIP1967Proxy`. ([#2542](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2542))
-
-### Breaking changes
-
-This release includes two small breaking changes in `TimelockController`.
-
-1. The `onlyRole` modifier in this contract was designed to let anyone through if the role was granted to `address(0)`,
-   allowing the possibility to to make a role "open", which can be used for `EXECUTOR_ROLE`. This modifier is now
-   replaced by `AccessControl.onlyRole`, which does not have this ability. The previous behavior was moved to the
-   modifier `TimelockController.onlyRoleOrOpenRole`.
-2. It was possible to make `PROPOSER_ROLE` an open role (as described in the previous item) if it was granted to
-   `address(0)`. This would affect the `schedule`, `scheduleBatch`, and `cancel` operations in `TimelockController`.
-   This ability was removed as it does not make sense to open up the `PROPOSER_ROLE` in the same way that it does for
-   `EXECUTOR_ROLE`.
-
-## 4.0.0 (2021-03-23)
-
- * Now targeting the 0.8.x line of Solidity compilers. For 0.6.x (resp 0.7.x) support, use version 3.4.0 (resp 3.4.0-solc-0.7) of OpenZeppelin.
- * `Context`: making `_msgData` return `bytes calldata` instead of `bytes memory` ([#2492](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2492))
- * `ERC20`: removed the `_setDecimals` function and the storage slot associated to decimals. ([#2502](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2502))
- * `Strings`: addition of a `toHexString` function.  ([#2504](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2504))
- * `EnumerableMap`: change implementation to optimize for `key → value` lookups instead of enumeration. ([#2518](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2518))
- * `GSN`: deprecate GSNv1 support in favor of upcoming support for GSNv2. ([#2521](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2521))
- * `ERC165`: remove uses of storage in the base ERC165 implementation. ERC165 based contracts now use storage-less virtual functions. Old behavior remains available in the `ERC165Storage` extension. ([#2505](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2505))
- * `Initializable`: make initializer check stricter during construction. ([#2531](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2531))
- * `ERC721`: remove enumerability of tokens from the base implementation. This feature is now provided separately through the `ERC721Enumerable` extension. ([#2511](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2511))
- * `AccessControl`: removed enumerability by default for a more lightweight contract. It is now opt-in through `AccessControlEnumerable`. ([#2512](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2512))
- * Meta Transactions: add `ERC2771Context` and a `MinimalForwarder` for meta-transactions. ([#2508](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2508))
- * Overall reorganization of the contract folder to improve clarity and discoverability. ([#2503](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2503))
- * `ERC20Capped`: optimize gas usage by enforcing the check directly in `_mint`. ([#2524](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2524))
- * Rename `UpgradeableProxy` to `ERC1967Proxy`. ([#2547](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2547))
- * `ERC777`: optimize the gas costs of the constructor. ([#2551](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2551))
- * `ERC721URIStorage`: add a new extension that implements the `_setTokenURI` behavior as it was available in 3.4.0. ([#2555](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2555))
- * `AccessControl`: added ERC165 interface detection. ([#2562](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2562))
- * `ERC1155`: make `uri` public so overloading function can call it using super. ([#2576](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2576))
-
-### Bug fixes for beta releases
-
- * `AccessControlEnumerable`: Fixed `renounceRole` not updating enumerable set of addresses for a role. ([#2572](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2572))
-
-### How to upgrade from 3.x
-
-Since this version has moved a few contracts to different directories, users upgrading from a previous version will need to adjust their import statements. To make this easier, the package includes a script that will migrate import statements automatically. After upgrading to the latest version of the package, run:
-
-```
-npx openzeppelin-contracts-migrate-imports
-```
-
-Make sure you're using git or another version control system to be able to recover from any potential error in our script.
-
-### How to upgrade from 4.0-beta.x
-
-Some further changes have been done between the different beta iterations. Transitions made during this period are configured in the `migrate-imports` script. Consequently, you can upgrade from any previous 4.0-beta.x version using the same script as described in the *How to upgrade from 3.x* section.
-
-## 3.4.2
-
- * `TimelockController`: Add additional isOperationReady check.
-
-## 3.4.1 (2021-03-03)
-
- * `ERC721`: made `_approve` an internal function (was private).
-
-## 3.4.0 (2021-02-02)
-
- * `BeaconProxy`: added new kind of proxy that allows simultaneous atomic upgrades. ([#2411](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2411))
- * `EIP712`: added helpers to verify EIP712 typed data signatures on chain. ([#2418](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2418))
- * `ERC20Permit`: added an implementation of the ERC20 permit extension for gasless token approvals. ([#2237](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2237))
- * Presets: added token presets with preminted fixed supply `ERC20PresetFixedSupply` and `ERC777PresetFixedSupply`. ([#2399](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2399))
- * `Address`: added `functionDelegateCall`, similar to the existing `functionCall`. ([#2333](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2333))
- * `Clones`: added a library for deploying EIP 1167 minimal proxies. ([#2449](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2449))
- * `Context`: moved from `contracts/GSN` to `contracts/utils`. ([#2453](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2453))
- * `PaymentSplitter`: replace usage of `.transfer()` with `Address.sendValue` for improved compatibility with smart wallets. ([#2455](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2455))
- * `UpgradeableProxy`: bubble revert reasons from initialization calls. ([#2454](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2454))
- * `SafeMath`: fix a memory allocation issue by adding new `SafeMath.tryOp(uint,uint)→(bool,uint)` functions. `SafeMath.op(uint,uint,string)→uint` are now deprecated. ([#2462](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2462))
- * `EnumerableMap`: fix a memory allocation issue by adding new `EnumerableMap.tryGet(uint)→(bool,address)` functions. `EnumerableMap.get(uint)→string` is now deprecated. ([#2462](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2462))
- * `ERC165Checker`: added batch `getSupportedInterfaces`. ([#2469](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2469))
- * `RefundEscrow`: `beneficiaryWithdraw` will forward all available gas to the beneficiary. ([#2480](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2480))
- * Many view and pure functions have been made virtual to customize them via overrides. In many cases this will not imply that other functions in the contract will automatically adapt to the overridden definitions. People who wish to override should consult the source code to understand the impact and if they need to override any additional functions to achieve the desired behavior.
-
-### Security Fixes
-
- * `ERC777`: fix potential reentrancy issues for custom extensions to `ERC777`. ([#2483](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2483))
-
-If you're using our implementation of ERC777 from version 3.3.0 or earlier, and you define a custom `_beforeTokenTransfer` function that writes to a storage variable, you may be vulnerable to a reentrancy attack. If you're affected and would like assistance please write to security@openzeppelin.com. [Read more in the pull request.](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2483)
-
-## 3.3.0 (2020-11-26)
-
- * Now supports both Solidity 0.6 and 0.7. Compiling with solc 0.7 will result in warnings. Install the `solc-0.7` tag to compile without warnings.
- * `Address`: added `functionStaticCall`, similar to the existing `functionCall`. ([#2333](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2333))
- * `TimelockController`: added a contract to augment access control schemes with a delay. ([#2354](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2354))
- * `EnumerableSet`: added `Bytes32Set`, for sets of `bytes32`. ([#2395](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2395))
-
-## 3.2.2-solc-0.7 (2020-10-28)
- * Resolve warnings introduced by Solidity 0.7.4. ([#2396](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2396))
-
-## 3.2.1-solc-0.7 (2020-09-15)
- * `ERC777`: Remove a warning about function state visibility in Solidity 0.7. ([#2327](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2327))
-
-## 3.2.0 (2020-09-10)
-
-### New features
- * Proxies: added the proxy contracts from OpenZeppelin SDK. ([#2335](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2335))
-
-#### Proxy changes with respect to OpenZeppelin SDK
-
-Aside from upgrading them from Solidity 0.5 to 0.6, we've changed a few minor things from the proxy contracts as they were found in OpenZeppelin SDK.
-
-- `UpgradeabilityProxy` was renamed to `UpgradeableProxy`.
-- `AdminUpgradeabilityProxy` was renamed to `TransparentUpgradeableProxy`.
-- `Proxy._willFallback` was renamed to `Proxy._beforeFallback`.
-- `UpgradeabilityProxy._setImplementation` and `AdminUpgradeabilityProxy._setAdmin` were made private.
-
-### Improvements
- * `Address.isContract`: switched from `extcodehash` to `extcodesize` for less gas usage. ([#2311](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2311))
-
-### Breaking changes
- * `ERC20Snapshot`: switched to using `_beforeTokenTransfer` hook instead of overriding ERC20 operations. ([#2312](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2312))
-
-This small change in the way we implemented `ERC20Snapshot` may affect users who are combining this contract with
-other ERC20 flavors, since it no longer overrides `_transfer`, `_mint`, and `_burn`. This can result in having to remove Solidity `override(...)` specifiers in derived contracts for these functions, and to instead have to add it for `_beforeTokenTransfer`. See [Using Hooks](https://docs.openzeppelin.com/contracts/3.x/extending-contracts#using-hooks) in the documentation.
-
-## 3.1.0 (2020-06-23)
-
-### New features
- * `SafeCast`: added functions to downcast signed integers (e.g. `toInt32`), improving usability of `SignedSafeMath`. ([#2243](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2243))
- * `functionCall`: new helpers that replicate Solidity's function call semantics, reducing the need to rely on `call`. ([#2264](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2264))
- * `ERC1155`: added support for a base implementation, non-standard extensions and a preset contract. ([#2014](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2014), [#2230](https://github.com/OpenZeppelin/openzeppelin-contracts/issues/2230))
-
-### Improvements
- * `ReentrancyGuard`: reduced overhead of using the `nonReentrant` modifier. ([#2171](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2171))
- * `AccessControl`: added a `RoleAdminChanged` event to `_setAdminRole`. ([#2214](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2214))
- * Made all `public` functions in the token preset contracts `virtual`. ([#2257](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2257))
-
-### Deprecations
- * `SafeERC20`: deprecated `safeApprove`. ([#2268](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2268))
-
-## 3.0.2 (2020-06-08)
-
-### Improvements
- * Added SPX license identifier to all contracts. ([#2235](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2235))
-
-## 3.0.1 (2020-04-27)
-
-### Bugfixes
- * `ERC777`: fixed the `_approve` internal function not validating some of their arguments for non-zero addresses. ([#2213](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2213))
-
-## 3.0.0 (2020-04-20)
-
-### New features
- * `AccessControl`: new contract for managing permissions in a system, replacement for `Ownable` and `Roles`. ([#2112](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2112))
- * `SafeCast`: new functions to convert to and from signed and unsigned values: `toUint256` and `toInt256`. ([#2123](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2123))
- * `EnumerableMap`: a new data structure for key-value pairs (like `mapping`) that can be iterated over. ([#2160](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2160))
-
-### Breaking changes
- * `ERC721`: `burn(owner, tokenId)` was removed, use `burn(tokenId)` instead. ([#2125](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2125))
- * `ERC721`: `_checkOnERC721Received` was removed. ([#2125](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2125))
- * `ERC721`: `_transferFrom` and `_safeTransferFrom` were renamed to `_transfer` and `_safeTransfer`. ([#2162](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2162))
- * `Ownable`: removed `_transferOwnership`. ([#2162](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2162))
- * `PullPayment`, `Escrow`: `withdrawWithGas` was removed. The old `withdraw` function now forwards all gas. ([#2125](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2125))
- * `Roles` was removed, use `AccessControl` as a replacement. ([#2112](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2112))
- * `ECDSA`: when receiving an invalid signature, `recover` now reverts instead of returning the zero address. ([#2114](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2114))
- * `Create2`: added an `amount` argument to `deploy` for contracts with `payable` constructors. ([#2117](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2117))
- * `Pausable`: moved to the `utils` directory. ([#2122](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2122))
- * `Strings`: moved to the `utils` directory. ([#2122](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2122))
- * `Counters`: moved to the `utils` directory. ([#2122](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2122))
- * `SignedSafeMath`: moved to the `math` directory. ([#2122](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2122))
- * `ERC20Snapshot`: moved to the `token/ERC20` directory. `snapshot` was changed into an `internal` function. ([#2122](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2122))
- * `Ownable`: moved to the `access` directory. ([#2120](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2120))
- * `Ownable`: removed `isOwner`. ([#2120](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2120))
- * `Secondary`: removed from the library, use `Ownable` instead. ([#2120](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2120))
- * `Escrow`, `ConditionalEscrow`, `RefundEscrow`: these now use `Ownable` instead of `Secondary`, their external API changed accordingly. ([#2120](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2120))
- * `ERC20`: removed `_burnFrom`. ([#2119](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2119))
- * `Address`: removed `toPayable`, use `payable(address)` instead. ([#2133](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2133))
- * `ERC777`: `_send`, `_mint` and `_burn` now use the caller as the operator. ([#2134](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2134))
- * `ERC777`: removed `_callsTokensToSend` and `_callTokensReceived`. ([#2134](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2134))
- * `EnumerableSet`: renamed `get` to `at`. ([#2151](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2151))
- * `ERC165Checker`: functions no longer have a leading underscore. ([#2150](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2150))
- * `ERC721Metadata`, `ERC721Enumerable`: these contracts were removed, and their functionality merged into `ERC721`. ([#2160](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2160))
- * `ERC721`: added a constructor for `name` and `symbol`. ([#2160](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2160))
- * `ERC20Detailed`: this contract was removed and its functionality merged into `ERC20`. ([#2161](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2161))
- * `ERC20`: added a constructor for `name` and `symbol`. `decimals` now defaults to 18. ([#2161](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2161))
- * `Strings`: renamed `fromUint256` to `toString` ([#2188](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2188))
-
-## 2.5.1 (2020-04-24)
-
-### Bugfixes
- * `ERC777`: fixed the `_send` and `_approve` internal functions not validating some of their arguments for non-zero addresses. ([#2212](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2212))
-
-## 2.5.0 (2020-02-04)
-
-### New features
- * `SafeCast.toUintXX`: new library for integer downcasting, which allows for safe operation on smaller types (e.g. `uint32`) when combined with `SafeMath`. ([#1926](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1926))
- * `ERC721Metadata`: added `baseURI`, which can be used for dramatic gas savings when all token URIs share a prefix (e.g. `http://api.myapp.com/tokens/<id>`). ([#1970](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1970))
- * `EnumerableSet`: new library for storing enumerable sets of values. Only `AddressSet` is supported in this release. ([#2061](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/2061))
- * `Create2`: simple library to make usage of the `CREATE2` opcode easier. ([#1744](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1744))
-
-### Improvements
- * `ERC777`: `_burn` is now internal, providing more flexibility and making it easier to create tokens that deflate. ([#1908](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1908))
- * `ReentrancyGuard`: greatly improved gas efficiency by using the net gas metering mechanism introduced in the Istanbul hardfork. ([#1992](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1992), [#1996](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1996))
- * `ERC777`: improve extensibility by making `_send` and related functions `internal`. ([#2027](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2027))
- * `ERC721`: improved revert reason when transferring tokens to a non-recipient contract. ([#2018](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2018))
-
-### Breaking changes
- * `ERC165Checker` now requires a minimum Solidity compiler version of 0.5.10. ([#1829](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1829))
-
-## 2.4.0 (2019-10-29)
-
-### New features
- * `Address.toPayable`: added a helper to convert between address types without having to resort to low-level casting. ([#1773](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1773))
- * Facilities to make metatransaction-enabled contracts through the Gas Station Network. ([#1844](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1844))
- * `Address.sendValue`: added a replacement to Solidity's `transfer`, removing the fixed gas stipend. ([#1962](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1962))
- * Added replacement for functions that don't forward all gas (which have been deprecated): ([#1976](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1976))
-   * `PullPayment.withdrawPaymentsWithGas(address payable payee)`
-   * `Escrow.withdrawWithGas(address payable payee)`
- * `SafeMath`: added support for custom error messages to `sub`, `div` and `mod` functions. ([#1828](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1828))
-
-### Improvements
- * `Address.isContract`: switched from `extcodesize` to `extcodehash` for less gas usage. ([#1802](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1802))
- * `ERC20` and `ERC777` updated to throw custom errors on subtraction overflows. ([#1828](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1828))
-
-### Deprecations
- * Deprecated functions that don't forward all gas: ([#1976](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1976))
-   * `PullPayment.withdrawPayments(address payable payee)`
-   * `Escrow.withdraw(address payable payee)`
-
-### Breaking changes
- * `Address` now requires a minimum Solidity compiler version of 0.5.5. ([#1802](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1802))
- * `SignatureBouncer` has been removed from drafts, both to avoid confusions with the GSN and `GSNRecipientSignature` (previously called `GSNBouncerSignature`) and because the API was not very clear. ([#1879](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/1879))
-
-### How to upgrade from 2.4.0-beta
-
-The final 2.4.0 release includes a refactor of the GSN contracts that will be a breaking change for 2.4.0-beta users.
-
- * The default empty implementations of `_preRelayedCall` and `_postRelayedCall` were removed and must now be explicitly implemented always in custom recipients. If your custom recipient didn't include an implementation, you can provide an empty one.
- * `GSNRecipient`, `GSNBouncerBase`, and `GSNContext` were all merged into `GSNRecipient`.
- * `GSNBouncerSignature` and `GSNBouncerERC20Fee` were renamed to `GSNRecipientSignature` and `GSNRecipientERC20Fee`.
- * It is no longer necessary to inherit from `GSNRecipient` when using `GSNRecipientSignature` and `GSNRecipientERC20Fee`.
-
-For example, a contract using `GSNBouncerSignature` would have to be changed in the following way.
-
-```diff
--contract MyDapp is GSNRecipient, GSNBouncerSignature {
-+contract MyDapp is GSNRecipientSignature {
-```
-
-Refer to the table below to adjust your inheritance list.
-
-| 2.4.0-beta                         | 2.4.0                        |
-| ---------------------------------- | ---------------------------- |
-| `GSNRecipient, GSNBouncerSignature`| `GSNRecipientSignature`      |
-| `GSNRecipient, GSNBouncerERC20Fee` | `GSNRecipientERC20Fee`       |
-| `GSNBouncerBase`                   | `GSNRecipient`               |
-
 ## 2.3.0 (2019-05-27)
 
-### New features
+### New features:
  * `ERC1820`: added support for interacting with the [ERC1820](https://eips.ethereum.org/EIPS/eip-1820) registry contract (`IERC1820Registry`), as well as base contracts that can be registered as implementers there. ([#1677](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1677))
  * `ERC777`: support for the [ERC777 token](https://eips.ethereum.org/EIPS/eip-777), which has multiple improvements over `ERC20` (but is backwards compatible with it) such as built-in burning, a more  straightforward permission system, and optional sender and receiver hooks on transfer (mandatory for contracts!). ([#1684](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1684))
  * All contracts now have revert reason strings, which give insight into error conditions, and help debug failing transactions. ([#1704](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1704))
 
-### Improvements
+### Improvements:
  * Reverted the Solidity version bump done in v2.2.0, setting the minimum compiler version to v0.5.0, to prevent unexpected build breakage. Users are encouraged however to stay on top of new compiler releases, which usually include bugfixes. ([#1729](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1729))
 
-### Bugfixes
+### Bugfixes:
  * `PostDeliveryCrowdsale`: some validations where skipped when paired with other crowdsale flavors, such as `AllowanceCrowdsale`, or `MintableCrowdsale` and `ERC20Capped`, which could cause buyers to not be able to claim their purchased tokens. ([#1721](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1721))
  * `ERC20._transfer`: the `from` argument was allowed to be the zero address, so it was possible to internally trigger a transfer of 0 tokens from the zero address. This address is not a valid destinatary of transfers, nor can it give or receive allowance, so this behavior was inconsistent. It now reverts. ([#1752](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1752))
 
 ## 2.2.0 (2019-03-14)
 
-### New features
+### New features:
  * `ERC20Snapshot`: create snapshots on demand of the token balances and total supply, to later retrieve and e.g. calculate dividends at a past time. ([#1617](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1617))
  * `SafeERC20`: `ERC20` contracts with no return value (i.e. that revert on failure) are now supported. ([#1655](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1655))
  * `ERC20`: added internal `_approve(address owner, address spender, uint256 value)`, allowing derived contracts to set the allowance of arbitrary accounts. ([#1609](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1609))
  * `ERC20Metadata`: added internal `_setTokenURI(string memory tokenURI)`. ([#1618](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1618))
  * `TimedCrowdsale`: added internal `_extendTime(uint256 newClosingTime)` as well as `TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime)` event allowing to extend the crowdsale, as long as it hasn't already closed.
 
-### Improvements
+### Improvements:
  * Upgraded the minimum compiler version to v0.5.2: this removes many Solidity warnings that were false positives. ([#1606](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1606))
  * `ECDSA`: `recover` no longer accepts malleable signatures (those using upper-range values for `s`, or 0/1 for `v`). ([#1622](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1622))
- * ``ERC721``'s transfers are now more gas efficient due to removal of unnecessary `SafeMath` calls. ([#1610](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1610))
+ * `ERC721`'s transfers are now more gas efficient due to removal of unnecessary `SafeMath` calls. ([#1610](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1610))
  * Fixed variable shadowing issues. ([#1606](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1606))
 
-### Bugfixes
+### Bugfixes:
  * (minor) `SafeERC20`: `safeApprove` wasn't properly checking for a zero allowance when attempting to set a non-zero allowance. ([#1647](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1647))
 
-### Breaking changes in drafts
+### Breaking changes in drafts:
  * `TokenMetadata` has been renamed to `ERC20Metadata`. ([#1618](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1618))
  * The library `Counter` has been renamed to `Counters` and its API has been improved. See an example in `ERC721`, lines [17](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/3cb4a00fce1da76196ac0ac3a0ae9702b99642b5/contracts/token/ERC721/ERC721.sol#L17) and [204](https://github.com/OpenZeppelin/openzeppelin-solidity/blob/3cb4a00fce1da76196ac0ac3a0ae9702b99642b5/contracts/token/ERC721/ERC721.sol#L204). ([#1610](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1610))
 
@@ -576,7 +47,7 @@ Refer to the table below to adjust your inheritance list.
 
 ## 2.1.0 (2019-01-04)
 
-### New features
+### New features:
  * Now targeting the 0.5.x line of Solidity compilers. For 0.4.24 support, use version 2.0 of OpenZeppelin.
  * `WhitelistCrowdsale`: a crowdsale where only whitelisted accounts (`WhitelistedRole`) can purchase tokens. Adding or removing accounts from the whitelist is done by whitelist admins (`WhitelistAdminRole`). Similar to the pre-2.0 `WhitelistedCrowdsale`. ([#1525](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1525), [#1589](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1589))
  * `RefundablePostDeliveryCrowdsale`: replacement for `RefundableCrowdsale` (deprecated, see below) where tokens are only granted once the crowdsale ends (if it meets its goal). ([#1543](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1543))
@@ -587,17 +58,17 @@ Refer to the table below to adjust your inheritance list.
  * Crowdsales: all constructors are now `public`, meaning it is not necessary to extend these contracts in order to deploy them. The exception is `FinalizableCrowdsale`, since it is meaningless unless extended. ([#1564](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1564))
  * `SignedSafeMath`: added overflow-safe operations for signed integers (`int256`). ([#1559](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1559), [#1588](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1588))
 
-### Improvements
- * The compiler version required by `Array` was behind the rest of the library so it was updated to `v0.4.24`. ([#1553](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1553))
+### Improvements:
+ * The compiler version required by `Array` was behind the rest of the libray so it was updated to `v0.4.24`. ([#1553](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1553))
  * Now conforming to a 4-space indentation code style. ([1508](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1508))
  * `ERC20`: more gas efficient due to removed redundant `require`s. ([#1409](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1409))
  * `ERC721`: fixed a bug that prevented internal data structures from being properly cleaned, missing potential gas refunds. ([#1539](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1539) and [#1549](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1549))
- * `ERC721`: general gas savings on `transferFrom`, `_mint` and `_burn`, due to redundant `require`s and `SSTORE`s. ([#1549](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1549))
+ * `ERC721`: general gas savings on `transferFrom`, `_mint` and `_burn`, due to redudant `require`s and `SSTORE`s. ([#1549](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1549))
 
-### Bugfixes
+### Bugfixes:
 
-### Breaking changes
+### Breaking changes:
 
-### Deprecations
+### Deprecations:
  * `ERC721._burn(address owner, uint256 tokenId)`: due to the `owner` parameter being unnecessary. ([#1550](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1550))
  * `RefundableCrowdsale`: due to trading abuse potential on crowdsales that miss their goal. ([#1543](https://github.com/OpenZeppelin/openzeppelin-solidity/pull/1543))

CODE_STYLE.md

@@ -0,0 +1,63 @@
+# Code Style
+
+We value clean code and consistency, and those are prerequisites for us to
+include new code in the repository. Before proposing a change, please read this
+document and take some time to familiarize yourself with the style of the
+existing codebase.
+
+## Solidity code
+
+In order to be consistent with all the other Solidity projects, we follow the
+[official recommendations documented in the Solidity style guide](http://solidity.readthedocs.io/en/latest/style-guide.html).
+
+Any exception or additions specific to our project are documented below.
+
+### Naming
+
+* Try to avoid acronyms and abbreviations.
+
+* All state variables should be private.
+
+* Private state variables should have an underscore prefix.
+
+    ```
+    contract TestContract {
+      uint256 private _privateVar;
+      uint256 internal _internalVar;
+    }
+    ```
+
+* Parameters must not be prefixed with an underscore.
+
+    ```
+    function test(uint256 testParameter1, uint256 testParameter2) {
+    ...
+    }
+    ```
+
+* Internal and private functions should have an underscore prefix.
+
+    ```
+    function _testInternal() internal {
+      ...
+    }
+    ```
+
+    ```
+    function _testPrivate() private {
+      ...
+    }
+    ```
+
+* Events should be emitted immediately after the state change that they
+  represent, and consequently they should be named in past tense.
+
+    ```
+    function _burn(address _who, uint256 _value) internal {
+      super._burn(_who, _value);
+      emit TokensBurned(_who, _value);
+    }
+    ```
+
+  Some standards (e.g. ERC20) use present tense, and in those cases the
+  standard specification prevails.

CONTRIBUTING.md

@@ -1,27 +1,30 @@
-Contributing to OpenZeppelin Contracts
+Contributing to OpenZeppelin
 =======
 
-We really appreciate and value contributions to OpenZeppelin Contracts. Please take 5' to review the items listed below to make sure that your contributions are merged as soon as possible.
+We really appreciate and value contributions to OpenZeppelin. Please take 5' to review the items listed below to make sure that your contributions are merged as soon as possible. 
 
 ## Contribution guidelines
 
-Smart contracts manage value and are highly vulnerable to errors and attacks. We have very strict [guidelines], please make sure to review them!
+Smart contracts manage value and are highly vulnerable to errors and attacks. We have very strict guidelines, please make sure to review them: ["Contribution guidelines wiki entry"](https://github.com/OpenZeppelin/openzeppelin-solidity/wiki/Contribution-guidelines).
 
 ## Creating Pull Requests (PRs)
 
 As a contributor, you are expected to fork this repository, work on your own fork and then submit pull requests. The pull requests will be reviewed and eventually merged into the main repo. See ["Fork-a-Repo"](https://help.github.com/articles/fork-a-repo/) for how this works.
 
+*IMPORTANT* 
+* Please see ["Git flow wiki entry"](https://github.com/OpenZeppelin/openzeppelin-solidity/wiki/Git-flow) for understanding how to use branches in this repository.
+
 ## A typical workflow
 
 1) Make sure your fork is up to date with the main repository:
 
 ```
-cd openzeppelin-contracts
-git remote add upstream https://github.com/OpenZeppelin/openzeppelin-contracts.git
+cd openzeppelin-solidity
+git remote add upstream https://github.com/OpenZeppelin/openzeppelin-solidity.git
 git fetch upstream
 git pull --rebase upstream master
 ```
-NOTE: The directory `openzeppelin-contracts` represents your fork's local copy.
+NOTE: The directory `openzeppelin-solidity` represents your fork's local copy.
 
 2) Branch out from `master` into `fix/some-bug-#123`:
 (Postfixing #123 will associate your PR with the issue #123 and make everyone's life easier =D)
@@ -29,7 +32,7 @@ NOTE: The directory `openzeppelin-contracts` represents your fork's local copy.
 git checkout -b fix/some-bug-#123
 ```
 
-3) Make your changes, add your files, commit, and push to your fork.
+3) Make your changes, add your files, commit and push to your fork.
 
 ```
 git add SomeFile.js
@@ -37,28 +40,19 @@ git commit "Fix some bug #123"
 git push origin fix/some-bug-#123
 ```
 
-4) Run tests, linter, etc. This can be done by running local continuous integration and make sure it passes.
+4) Go to [github.com/OpenZeppelin/openzeppelin-solidity](https://github.com/OpenZeppelin/zeppelin-solidity) in your web browser and issue a new pull request.
 
-```bash
-npm test
-npm run lint
-```
+*IMPORTANT* Read the PR template very carefully and make sure to follow all the instructions. These instructions 
+refer to some very important conditions that your PR must meet in order to be accepted, such as making sure that all tests pass, JS linting tests pass, solidity linting tests pass, etc.
 
-5) Go to [github.com/OpenZeppelin/openzeppelin-contracts](https://github.com/OpenZeppelin/openzeppelin-contracts) in your web browser and issue a new pull request.
+5) Maintainers will review your code and possibly ask for changes before your code is pulled in to the main repository. We'll check that all tests pass, review the coding style, and check for general code correctness. If everything is OK, we'll merge your pull request and your code will be part of OpenZeppelin.
 
-*IMPORTANT* Read the PR template very carefully and make sure to follow all the instructions. These instructions
-refer to some very important conditions that your PR must meet in order to be accepted, such as making sure that all tests pass, JS linting tests pass, Solidity linting tests pass, etc.
-
-6) Maintainers will review your code and possibly ask for changes before your code is pulled in to the main repository. We'll check that all tests pass, review the coding style, and check for general code correctness. If everything is OK, we'll merge your pull request and your code will be part of OpenZeppelin Contracts.
-
-*IMPORTANT* Please pay attention to the maintainer's feedback, since it's a necessary step to keep up with the standards OpenZeppelin Contracts attains to.
+*IMPORTANT* Please pay attention to the maintainer's feedback, since its a necessary step to keep up with the standards OpenZeppelin attains to.
 
 ## All set!
 
-If you have any questions, feel free to post them to github.com/OpenZeppelin/openzeppelin-contracts/issues.
+If you have any questions feel free to post them to github.com/OpenZeppelin/openzeppelin-solidity/issues.
 
-Finally, if you're looking to collaborate and want to find easy tasks to start, look at the issues we marked as ["Good first issue"](https://github.com/OpenZeppelin/openzeppelin-contracts/labels/good%20first%20issue).
+Finally, if you're looking to collaborate and want to find easy tasks to start, look at the issues we marked as ["Good first issue"](https://github.com/OpenZeppelin/openzeppelin-solidity/labels/good%20first%20issue).
 
 Thanks for your time and code!
-
-[guidelines]: GUIDELINES.md

DOCUMENTATION.md

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

GUIDELINES.md

@@ -1,105 +0,0 @@
-Design Guidelines
-=======
-
-These are some global design goals in OpenZeppelin Contracts.
-
-#### D0 - Security in Depth
-We strive to provide secure, tested, audited code. To achieve this, we need to match intention with function. Thus, documentation, code clarity, community review and security discussions are fundamental.
-
-#### D1 - Simple and Modular
-Simpler code means easier audits, and better understanding of what each component does. We look for small files, small contracts, and small functions. If you can separate a contract into two independent functionalities you should probably do it.
-
-#### D2 - Naming Matters
-
-We take our time with picking names. Code is going to be written once, and read hundreds of times. Renaming for clarity is encouraged.
-
-#### D3 - Tests
-
-Write tests for all your code. We encourage Test Driven Development so we know when our code is right. Even though not all code in the repository is tested at the moment, we aim to test every line of code in the future.
-
-#### D4 - Check preconditions and post-conditions
-
-A very important way to prevent vulnerabilities is to catch a contract’s inconsistent state as early as possible. This is why we want functions to check pre- and post-conditions for executing its logic. When writing code, ask yourself what you are expecting to be true before and after the function runs, and express it in code.
-
-#### D5 - Code Consistency
-
-Consistency on the way classes are used is paramount to an easier understanding of the library. The codebase should be as unified as possible. Read existing code and get inspired before you write your own. Follow the style guidelines. Don’t hesitate to ask for help on how to best write a specific piece of code.
-
-#### D6 - Regular Audits
-Following good programming practices is a way to reduce the risk of vulnerabilities, but professional code audits are still needed. We will perform regular code audits on major releases, and hire security professionals to provide independent review.
-
-# Style Guidelines
-
-The design guidelines have quite a high abstraction level. These style guidelines are more concrete and easier to apply, and also more opinionated. We value clean code and consistency, and those are prerequisites for us to include new code in the repository. Before proposing a change, please read these guidelines and take some time to familiarize yourself with the style of the existing codebase.
-
-## Solidity code
-
-In order to be consistent with all the other Solidity projects, we follow the
-[official recommendations documented in the Solidity style guide](http://solidity.readthedocs.io/en/latest/style-guide.html).
-
-Any exception or additions specific to our project are documented below.
-
-* Try to avoid acronyms and abbreviations.
-
-* All state variables should be private.
-
-* Private state variables should have an underscore prefix.
-
-    ```
-    contract TestContract {
-      uint256 private _privateVar;
-      uint256 internal _internalVar;
-    }
-    ```
-
-* Parameters must not be prefixed with an underscore.
-
-    ```
-    function test(uint256 testParameter1, uint256 testParameter2) {
-    ...
-    }
-    ```
-
-* Internal and private functions should have an underscore prefix.
-
-    ```
-    function _testInternal() internal {
-      ...
-    }
-    ```
-
-    ```
-    function _testPrivate() private {
-      ...
-    }
-    ```
-
-* Events should be emitted immediately after the state change that they
-  represent, and consequently they should be named in past tense.
-
-    ```
-    function _burn(address who, uint256 value) internal {
-      super._burn(who, value);
-      emit TokensBurned(who, value);
-    }
-    ```
-
-  Some standards (e.g. ERC20) use present tense, and in those cases the
-  standard specification prevails.
-  
-* Interface names should have a capital I prefix.
-
-    ```
-    interface IERC777 {
-    ```
-
-
-## Tests
-
-* Tests Must be Written Elegantly
-
-    Tests are a good way to show how to use the library, and maintaining them is extremely necessary. Don't write long tests, write helper functions to make them be as short and concise as possible (they should take just a few lines each), and use good variable names.
-
-* Tests Must not be Random
-
-    Inputs for tests should not be generated randomly. Accounts used to create test contracts are an exception, those can be random. Also, the type and structure of outputs should be checked.

LICENSE

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

README.md

@@ -1,84 +1,63 @@
-# <img src="logo.svg" alt="OpenZeppelin" height="40px">
+# <img src="logo.png" alt="OpenZeppelin" width="400px">
 
-[![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-blue)](https://docs.openzeppelin.com/contracts)
-[![NPM Package](https://img.shields.io/npm/v/@openzeppelin/contracts.svg)](https://www.npmjs.org/package/@openzeppelin/contracts)
-[![Coverage Status](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts/graph/badge.svg)](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts)
-[![gitpoap badge](https://public-api.gitpoap.io/v1/repo/OpenZeppelin/openzeppelin-contracts/badge)](https://www.gitpoap.io/gh/OpenZeppelin/openzeppelin-contracts)
+[![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)
 
-**A library for secure smart contract development.** Build on a solid foundation of community-vetted code.
+**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.
 
- * Implementations of standards like [ERC20](https://docs.openzeppelin.com/contracts/erc20) and [ERC721](https://docs.openzeppelin.com/contracts/erc721).
- * Flexible [role-based permissioning](https://docs.openzeppelin.com/contracts/access-control) scheme.
- * Reusable [Solidity components](https://docs.openzeppelin.com/contracts/utilities) to build custom contracts and complex decentralized systems.
+## Install
 
-:mage: **Not sure how to get started?** Check out [Contracts Wizard](https://wizard.openzeppelin.com/) — an interactive smart contract generator.
-
-:building_construction: **Want to scale your decentralized application?** Check out [OpenZeppelin Defender](https://openzeppelin.com/defender) — a secure platform for automating and monitoring your operations.
-
-## Overview
-
-### Installation
-
-```console
-$ npm install @openzeppelin/contracts
+```
+npm install openzeppelin-solidity
 ```
 
-OpenZeppelin Contracts features a [stable API](https://docs.openzeppelin.com/contracts/releases-stability#api-stability), which means that your contracts won't break unexpectedly when upgrading to a newer minor version.
+OpenZeppelin features a stable API, which means your contracts won't break unexpectedly when upgrading to a newer minor version. You can read ṫhe details in our [API Stability](https://forum.zeppelin.solutions/t/api-stability/138) document.
 
-An alternative to npm is to use the GitHub repository (`openzeppelin/openzeppelin-contracts`) to retrieve the contracts. When doing this, make sure to specify the tag for a release such as `v4.5.0`, instead of using the `master` branch.
+## Usage
 
-### Usage
-
-Once installed, you can use the contracts in the library by importing them:
+To write your custom contracts, import ours and extend them through inheritance.
 
 ```solidity
-pragma solidity ^0.8.0;
+pragma solidity ^0.5.0;
 
-import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Full.sol';
+import 'openzeppelin-solidity/contracts/token/ERC721/ERC721Mintable.sol';
 
-contract MyCollectible is ERC721 {
-    constructor() ERC721("MyCollectible", "MCO") {
-    }
+contract MyNFT is ERC721Full, ERC721Mintable {
+  constructor() ERC721Full("MyNFT", "MNFT") public {
+  }
 }
 ```
 
-_If you're new to smart contract development, head to [Developing Smart Contracts](https://docs.openzeppelin.com/learn/developing-smart-contracts) to learn about creating a new project and compiling your contracts._
+> You need an ethereum development framework for the above import statements to work! Check out these guides for [Truffle], [Embark] or [Buidler].
 
-To keep your system secure, you should **always** use the installed code as-is, and neither copy-paste it from online sources nor modify it yourself. The library is designed so that only the contracts and functions you use are deployed, so you don't need to worry about it needlessly increasing gas costs.
-
-## Learn More
-
-The guides in the [documentation site](https://docs.openzeppelin.com/contracts) will teach about different concepts, and how to use the related contracts that OpenZeppelin Contracts provides:
-
-* [Access Control](https://docs.openzeppelin.com/contracts/access-control): decide who can perform each of the actions on your system.
-* [Tokens](https://docs.openzeppelin.com/contracts/tokens): create tradeable assets or collectives, and distribute them via [Crowdsales](https://docs.openzeppelin.com/contracts/crowdsales).
-* [Gas Station Network](https://docs.openzeppelin.com/contracts/gsn): let your users interact with your contracts without having to pay for gas themselves.
-* [Utilities](https://docs.openzeppelin.com/contracts/utilities): generic useful tools including non-overflowing math, signature verification, and trustless paying systems.
-
-The [full API](https://docs.openzeppelin.com/contracts/api/token/ERC20) is also thoroughly documented, and serves as a great reference when developing your smart contract application. You can also ask for help or follow Contracts's development in the [community forum](https://forum.openzeppelin.com).
-
-Finally, you may want to take a look at the [guides on our blog](https://blog.openzeppelin.com/guides), which cover several common use cases and good practices. The following articles provide great background reading, though please note that some of the referenced tools have changed, as the tooling in the ecosystem continues to rapidly evolve.
-
-* [The Hitchhiker’s Guide to Smart Contracts in Ethereum](https://blog.openzeppelin.com/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05) will help you get an overview of the various tools available for smart contract development, and help you set up your environment.
-* [A Gentle Introduction to Ethereum Programming, Part 1](https://blog.openzeppelin.com/a-gentle-introduction-to-ethereum-programming-part-1-783cc7796094) provides very useful information on an introductory level, including many basic concepts from the Ethereum platform.
-* For a more in-depth dive, you may read the guide [Designing the Architecture for Your Ethereum Application](https://blog.openzeppelin.com/designing-the-architecture-for-your-ethereum-application-9cec086f8317), which discusses how to better structure your application and its relationship to the real world.
+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
 
-This project is maintained by [OpenZeppelin](https://openzeppelin.com), 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.
+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.
 
-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 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 latest audit was done on October 2018 on version 2.0.0.
 
-We have a [**bug bounty program** on Immunefi](https://www.immunefi.com/bounty/openzeppelin). Please report any security issues you find through the Immunefi dashboard, or reach out to security@openzeppelin.com.
-
-Critical bug fixes will be backported to past major releases.
+Please report any security issues you find to security@openzeppelin.org.
 
 ## Contribute
 
-OpenZeppelin Contracts exists thanks to its contributors. There are many ways you can participate and help build high quality software. Check out the [contribution guide](CONTRIBUTING.md)!
+OpenZeppelin exists thanks to its contributors. There are many ways you can participate and help build high quality software. Check out the [contribution guide]!
 
 ## License
 
-OpenZeppelin Contracts is released under the [MIT License](LICENSE).
+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
+[forum]: https://forum.zeppelin.solutions
+[Zeppelin]: https://zeppelin.solutions
+[contribution guide]: CONTRIBUTING.md
+[Truffle]: https://truffleframework.com/docs/truffle/quickstart
+[Embark]: https://embark.status.im/docs/quick_start.html
+[Buidler]: https://buidler.dev/guides/#getting-started

RELEASING.md

@@ -1,20 +1,83 @@
 # Releasing
 
-> Visit the documentation for [details about release schedule].
+This document describes our release process, and contains the steps to be followed by an OpenZeppelin maintainer at the several stages of a release.
 
-Start on an up-to-date `master` branch.
+We release a new version of OpenZeppelin monthly. Release cycles are tracked in the [issue milestones](https://github.com/OpenZeppelin/openzeppelin-solidity/milestones).
 
-Create the release branch with `npm run release start minor`.
+Each release has at least one release candidate published first, intended for community review and any critical fixes that may come out of it. At the moment we leave 1 week between the first release candidate and the final release.
 
-Publish a release candidate with `npm run release rc`.
+Before starting make sure to verify the following items.
+* Your local `master` branch is in sync with your `upstream` remote (it may have another name depending on your setup).
+* Your repo is clean, particularly with no untracked files in the contracts and tests directories. Verify with `git clean -n`.
 
-Publish the final release with `npm run release final`.
 
-Follow the general [OpenZeppelin Contracts release checklist].
+## Creating the release branch
 
-[details about release schedule]: https://docs.openzeppelin.com/contracts/releases-stability
-[OpenZeppelin Contracts release checklist]: https://github.com/OpenZeppelin/code-style/blob/master/RELEASE_CHECKLIST.md
+We'll refer to a release `vX.Y.Z`.
 
+```
+git checkout master
+git checkout -b release-vX.Y.Z
+```
+
+## Creating a release candidate
+
+Once in the release branch, change the version string in `package.json`, `package-lock.json` and `ethpm.json` to `X.Y.Z-rc.R`. (This will be `X.Y.Z-rc.1` for the first release candidate.) Commit these changes and tag the commit as `vX.Y.Z-rc.R`.
+
+```
+git add package.json package-lock.json ethpm.json
+git commit -m "Release candidate vX.Y.Z-rc.R"
+git tag -a vX.Y.Z-rc.R
+git push upstream release-vX.Y.Z
+git push upstream vX.Y.Z-rc.R
+```
+
+Draft the release notes in our [GitHub releases](https://github.com/OpenZeppelin/openzeppelin-solidity/releases). Make sure to mark it as a pre-release! Try to be consistent with our previous release notes in the title and format of the text. Release candidates don't need a detailed changelog, but make sure to include a link to GitHub's compare page.
+
+Once the CI run for the new tag is green, publish on npm under the `next` tag. You should see the contracts compile automatically.
+
+```
+npm publish --tag next
+```
+
+Publish the release notes on GitHub and the forum, and ask our community manager to announce the release candidate on at least Twitter.
+
+## Creating the final release
+
+Make sure to have the latest changes from `upstream` in your local release branch.
+
+```
+git checkout release-vX.Y.Z
+git pull upstream
+```
+
+Before starting the release process, make one final commit to CHANGELOG.md, including the date of the release.
+
+Change the version string in `package.json`, `package-lock.json` and `ethpm.json` removing the "-rc.R" suffix. Commit these changes and tag the commit as `vX.Y.Z`.
+
+```
+git add package.json package-lock.json ethpm.json
+git commit -m "Release vX.Y.Z"
+git tag -a vX.Y.Z
+git push upstream release-vX.Y.Z
+git push upstream vX.Y.Z
+```
+
+Draft the release notes in GitHub releases. Try to be consistent with our previous release notes in the title and format of the text. Make sure to include a detailed changelog.
+
+Once the CI run for the new tag is green, publish on npm. You should see the contracts compile automatically.
+
+```
+npm publish
+```
+
+Publish the release notes on GitHub and ask our community manager to announce the release!
+
+Delete the `next` tag in the npm package as there is no longer a release candidate.
+
+```
+npm dist-tag rm --otp $2FA_CODE openzeppelin-solidity next
+```
 
 ## Merging the release branch
 

SECURITY.md

@@ -1,20 +0,0 @@
-# Security Policy
-
-## Bug Bounty
-
-We have a [**bug bounty program** on Immunefi](https://www.immunefi.com/bounty/openzeppelin). Please report any security issues you find through the Immunefi dashboard, or reach out to security@openzeppelin.com.
-
-Critical bug fixes will be backported to past major releases.
-
-## Supported Versions
-
-The recommendation is to use the latest version available.
-
-| Version | Supported                            |
-| ------- | ------------------------------------ |
-| 4.x     | :white_check_mark::white_check_mark: |
-| 3.4     | :white_check_mark:                   |
-| 2.5     | :white_check_mark:                   |
-| < 2.0   | :x:                                  |
-
-Note that the Solidity language itself only guarantees security updates for the latest release.

audit/2017-03.md

@@ -1,7 +1,5 @@
 # OpenZeppelin Audit
 
-NOTE ON 2021-07-19: This report makes reference to Zeppelin, OpenZeppelin, OpenZeppelin [C]ontracts, the OpenZeppelin team, and OpenZeppelin library. Many of these things have since been renamed and know that this audit applies to what is currently called the OpenZeppelin Contracts which are maintained by the OpenZeppelin Conracts Community.
-
 March, 2017
 Authored by Dennis Peterson and Peter Vessenes
 
@@ -133,7 +131,7 @@ I presume that the goal of this contract is to allow and annotate a migration to
 
 We like these pauses! Note that these allow significant griefing potential by owners, and that this might not be obvious to participants in smart contracts using the OpenZeppelin framework. We would recommend that additional sample logic be added to for instance the TokenContract showing safer use of the pause and resume functions. In particular, we would recommend a timelock after which anyone could unpause the contract.
 
-The modifiers use the pattern `if(bool){_;}`. This is fine for functions that return false upon failure, but could be problematic for functions expected to throw upon failure. See our comments above on standardizing on `throw` or `return(false)`.
+The modifers use the pattern `if(bool){_;}`. This is fine for functions that return false upon failure, but could be problematic for functions expected to throw upon failure. See our comments above on standardizing on `throw` or `return(false)`.
 
 ## Ownership
 

certora/Makefile

@@ -1,24 +0,0 @@
-default: help
-
-PATCH         = applyHarness.patch
-CONTRACTS_DIR = ../contracts
-MUNGED_DIR    = munged
-
-help:
-	@echo "usage:"
-	@echo "  make clean:  remove all generated files (those ignored by git)"
-	@echo "  make $(MUNGED_DIR): create $(MUNGED_DIR) directory by applying the patch file to $(CONTRACTS_DIR)"
-	@echo "  make record: record a new patch file capturing the differences between $(CONTRACTS_DIR) and $(MUNGED_DIR)"
-
-munged:  $(wildcard $(CONTRACTS_DIR)/*.sol) $(PATCH)
-	rm -rf $@
-	cp -r $(CONTRACTS_DIR) $@
-	patch -p0 -d $@ < $(PATCH)
-
-record:
-	diff -ruN $(CONTRACTS_DIR) $(MUNGED_DIR) | sed 's+../contracts/++g' | sed 's+munged/++g' > $(PATCH)
-
-clean:
-	git clean -fdX
-	touch $(PATCH)
-

certora/README.md

@@ -1,56 +0,0 @@
-# Running the certora verification tool
-
-These instructions detail the process for running CVT on the OpenZeppelin (Wizard/Governor) contracts.
-
-Documentation for CVT and the specification language are available
-[here](https://certora.atlassian.net/wiki/spaces/CPD/overview)
-
-## Running the verification
-
-The scripts in the `certora/scripts` directory are used to submit verification
-jobs to the Certora verification service. After the job is complete, the results will be available on
-[the Certora portal](https://vaas-stg.certora.com/).
-
-These scripts should be run from the root directory; for example by running
-
-```
-sh certora/scripts/verifyAll.sh <meaningful comment>
-```
-
-The most important of these is `verifyAll.sh`, which checks
-all of the harnessed contracts (`certora/harness/Wizard*.sol`) against all of
-the specifications (`certora/spec/*.spec`).
-
-The other scripts run a subset of the specifications or the contracts.  You can
-verify different contracts or specifications by changing the `--verify` option,
-and you can run a single rule or method with the `--rule` or `--method` option.
-
-For example, to verify the `WizardFirstPriority` contract against the
-`GovernorCountingSimple` specification, you could change the `--verify` line of
-the `WizardControlFirstPriortity.sh` script to:
-
-```
---verify WizardFirstPriority:certora/specs/GovernorCountingSimple.spec \
-```
-
-## Adapting to changes in the contracts
-
-Some of our rules require the code to be simplified in various ways. Our
-primary tool for performing these simplifications is to run verification on a
-contract that extends the original contracts and overrides some of the methods.
-These "harness" contracts can be found in the `certora/harness` directory.
-
-This pattern does require some modifications to the original code: some methods
-need to be made virtual or public, for example. These changes are handled by
-applying a patch to the code before verification.
-
-When one of the `verify` scripts is executed, it first applies the patch file
-`certora/applyHarness.patch` to the `contracts` directory, placing the output
-in the `certora/munged` directory. We then verify the contracts in the
-`certora/munged` directory.
-
-If the original contracts change, it is possible to create a conflict with the
-patch. In this case, the verify scripts will report an error message and output
-rejected changes in the `munged` directory. After merging the changes, run
-`make record` in the `certora` directory; this will regenerate the patch file,
-which can then be checked into git.

certora/applyHarness.patch

@@ -1,101 +0,0 @@
-diff -ruN .gitignore .gitignore
---- .gitignore	1969-12-31 19:00:00.000000000 -0500
-+++ .gitignore	2021-12-09 14:46:33.923637220 -0500
-@@ -0,0 +1,2 @@
-+*
-+!.gitignore
-diff -ruN governance/compatibility/GovernorCompatibilityBravo.sol governance/compatibility/GovernorCompatibilityBravo.sol
---- governance/compatibility/GovernorCompatibilityBravo.sol	2021-12-03 15:24:56.523654357 -0500
-+++ governance/compatibility/GovernorCompatibilityBravo.sol	2021-12-09 14:46:33.923637220 -0500
-@@ -245,7 +245,7 @@
-     /**
-      * @dev See {Governor-_quorumReached}. In this module, only forVotes count toward the quorum.
-      */
--    function _quorumReached(uint256 proposalId) internal view virtual override returns (bool) {
-+    function _quorumReached(uint256 proposalId) public view virtual override returns (bool) { // HARNESS: changed to public from internal
-         ProposalDetails storage details = _proposalDetails[proposalId];
-         return quorum(proposalSnapshot(proposalId)) <= details.forVotes;
-     }
-@@ -253,7 +253,7 @@
-     /**
-      * @dev See {Governor-_voteSucceeded}. In this module, the forVotes must be scritly over the againstVotes.
-      */
--    function _voteSucceeded(uint256 proposalId) internal view virtual override returns (bool) {
-+    function _voteSucceeded(uint256 proposalId) public view virtual override returns (bool) { // HARNESS: changed to public from internal
-         ProposalDetails storage details = _proposalDetails[proposalId];
-         return details.forVotes > details.againstVotes;
-     }
-diff -ruN governance/extensions/GovernorCountingSimple.sol governance/extensions/GovernorCountingSimple.sol
---- governance/extensions/GovernorCountingSimple.sol	2021-12-03 15:24:56.523654357 -0500
-+++ governance/extensions/GovernorCountingSimple.sol	2021-12-09 14:46:33.923637220 -0500
-@@ -64,7 +64,7 @@
-     /**
-      * @dev See {Governor-_quorumReached}.
-      */
--    function _quorumReached(uint256 proposalId) internal view virtual override returns (bool) {
-+    function _quorumReached(uint256 proposalId) public view virtual override returns (bool) {
-         ProposalVote storage proposalvote = _proposalVotes[proposalId];
- 
-         return quorum(proposalSnapshot(proposalId)) <= proposalvote.forVotes + proposalvote.abstainVotes;
-@@ -73,7 +73,7 @@
-     /**
-      * @dev See {Governor-_voteSucceeded}. In this module, the forVotes must be strictly over the againstVotes.
-      */
--    function _voteSucceeded(uint256 proposalId) internal view virtual override returns (bool) {
-+    function _voteSucceeded(uint256 proposalId) public view virtual override returns (bool) {
-         ProposalVote storage proposalvote = _proposalVotes[proposalId];
- 
-         return proposalvote.forVotes > proposalvote.againstVotes;
-diff -ruN governance/extensions/GovernorTimelockControl.sol governance/extensions/GovernorTimelockControl.sol
---- governance/extensions/GovernorTimelockControl.sol	2021-12-03 15:24:56.523654357 -0500
-+++ governance/extensions/GovernorTimelockControl.sol	2021-12-09 14:46:33.923637220 -0500
-@@ -111,7 +111,7 @@
-         bytes[] memory calldatas,
-         bytes32 descriptionHash
-     ) internal virtual override {
--        _timelock.executeBatch{value: msg.value}(targets, values, calldatas, 0, descriptionHash);
-+         _timelock.executeBatch{value: msg.value}(targets, values, calldatas, 0, descriptionHash);
-     }
- 
-     /**
-diff -ruN governance/Governor.sol governance/Governor.sol
---- governance/Governor.sol	2021-12-03 15:24:56.523654357 -0500
-+++ governance/Governor.sol	2021-12-09 14:46:56.411503587 -0500
-@@ -38,8 +38,8 @@
- 
-     string private _name;
- 
--    mapping(uint256 => ProposalCore) private _proposals;
--
-+    mapping(uint256 => ProposalCore) public _proposals;
-+ 
-     /**
-      * @dev Restrict access to governor executing address. Some module might override the _executor function to make
-      * sure this modifier is consistent with the execution model.
-@@ -167,12 +167,12 @@
-     /**
-      * @dev Amount of votes already cast passes the threshold limit.
-      */
--    function _quorumReached(uint256 proposalId) internal view virtual returns (bool);
-+    function _quorumReached(uint256 proposalId) public view virtual returns (bool); // HARNESS: changed to public from internal
- 
-     /**
-      * @dev Is the proposal successful or not.
-      */
--    function _voteSucceeded(uint256 proposalId) internal view virtual returns (bool);
-+    function _voteSucceeded(uint256 proposalId) public view virtual returns (bool); // HARNESS: changed to public from internal
- 
-     /**
-      * @dev Register a vote with a given support and voting weight.
-diff -ruN token/ERC20/extensions/ERC20Votes.sol token/ERC20/extensions/ERC20Votes.sol
---- token/ERC20/extensions/ERC20Votes.sol	2021-12-03 15:24:56.527654330 -0500
-+++ token/ERC20/extensions/ERC20Votes.sol	2021-12-09 14:46:33.927637196 -0500
-@@ -84,7 +84,7 @@
-      *
-      * - `blockNumber` must have been already mined
-      */
--    function getPastVotes(address account, uint256 blockNumber) public view returns (uint256) {
-+    function getPastVotes(address account, uint256 blockNumber) public view virtual returns (uint256) {
-         require(blockNumber < block.number, "ERC20Votes: block not yet mined");
-         return _checkpointsLookup(_checkpoints[account], blockNumber);
-     }

certora/harnesses/ERC20VotesHarness.sol

@@ -1,28 +0,0 @@
-import "../munged/token/ERC20/extensions/ERC20Votes.sol";
-
-contract ERC20VotesHarness is ERC20Votes {
-    constructor(string memory name, string memory symbol) ERC20Permit(name) ERC20(name, symbol) {}
-
-    mapping(address => mapping(uint256 => uint256)) public _getPastVotes;
-
-    function _afterTokenTransfer(
-        address from,
-        address to,
-        uint256 amount
-    ) internal virtual override {
-        super._afterTokenTransfer(from, to, amount);
-        _getPastVotes[from][block.number] -= amount;
-        _getPastVotes[to][block.number] += amount;
-    }
-
-    /**
-     * @dev Change delegation for `delegator` to `delegatee`.
-     *
-     * Emits events {DelegateChanged} and {DelegateVotesChanged}.
-     */
-    function _delegate(address delegator, address delegatee) internal virtual override{
-        super._delegate(delegator, delegatee);
-        _getPastVotes[delegator][block.number] -= balanceOf(delegator);
-        _getPastVotes[delegatee][block.number] += balanceOf(delegator);
-    }
-}

certora/harnesses/WizardControlFirstPriority.sol

@@ -1,150 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.2;
-
-import "../munged/governance/Governor.sol";
-import "../munged/governance/extensions/GovernorCountingSimple.sol";
-import "../munged/governance/extensions/GovernorVotes.sol";
-import "../munged/governance/extensions/GovernorVotesQuorumFraction.sol";
-import "../munged/governance/extensions/GovernorTimelockControl.sol";
-import "../munged/governance/extensions/GovernorProposalThreshold.sol";
-
-/* 
-Wizard options:
-ProposalThreshhold = 10
-ERC20Votes
-TimelockController
-*/
-
-contract WizardControlFirstPriority is Governor, GovernorProposalThreshold, GovernorCountingSimple, GovernorVotes, GovernorVotesQuorumFraction, GovernorTimelockControl {
-    constructor(ERC20Votes _token, TimelockController _timelock, string memory name, uint256 quorumFraction)
-        Governor(name)
-        GovernorVotes(_token)
-        GovernorVotesQuorumFraction(quorumFraction)
-        GovernorTimelockControl(_timelock)
-    {}
-
-    //HARNESS
-
-    function isExecuted(uint256 proposalId) public view returns (bool) {
-        return _proposals[proposalId].executed;
-    }
-    
-    function isCanceled(uint256 proposalId) public view returns (bool) {
-        return _proposals[proposalId].canceled;
-    }
-
-    uint256 _votingDelay;
-
-    uint256 _votingPeriod;
-
-    uint256 _proposalThreshold;
-
-    mapping(uint256 => uint256) public ghost_sum_vote_power_by_id;
-
-    function _castVote(
-        uint256 proposalId,
-        address account,
-        uint8 support,
-        string memory reason
-    ) internal override virtual returns (uint256) {
-        
-        uint256 deltaWeight = super._castVote(proposalId, account, support, reason);  //HARNESS
-        ghost_sum_vote_power_by_id[proposalId] += deltaWeight;
-
-        return deltaWeight;        
-    }
-    
-    function snapshot(uint256 proposalId) public view returns (uint64) {
-        return _proposals[proposalId].voteStart._deadline;
-    }
-
-
-    function getExecutor() public view returns (address){
-        return _executor();
-    }
-
-    // original code, harnessed
-
-    function votingDelay() public view override returns (uint256) {     // HARNESS: pure -> view
-        return _votingDelay;                                            // HARNESS: parametric
-    }
-
-    function votingPeriod() public view override returns (uint256) {    // HARNESS: pure -> view
-        return _votingPeriod;                                           // HARNESS: parametric
-    }
-
-    function proposalThreshold() public view override returns (uint256) {   // HARNESS: pure -> view
-        return _proposalThreshold;                                          // HARNESS: parametric
-    }
-
-    // original code, not harnessed
-    // The following functions are overrides required by Solidity.
-
-    function quorum(uint256 blockNumber)
-        public
-        view
-        override(IGovernor, GovernorVotesQuorumFraction)
-        returns (uint256)
-    {
-        return super.quorum(blockNumber);
-    }
-
-    function getVotes(address account, uint256 blockNumber)
-        public
-        view
-        override(IGovernor, GovernorVotes)
-        returns (uint256)
-    {
-        return super.getVotes(account, blockNumber);
-    }
-
-    function state(uint256 proposalId)
-        public
-        view
-        override(Governor, GovernorTimelockControl)
-        returns (ProposalState)
-    {
-        return super.state(proposalId);
-    }
-
-    function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description)
-        public
-        override(Governor, GovernorProposalThreshold, IGovernor)
-        returns (uint256)
-    {
-        return super.propose(targets, values, calldatas, description);
-    }
-
-    function _execute(uint256 proposalId, address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
-        internal
-        override(Governor, GovernorTimelockControl)
-    {
-        super._execute(proposalId, targets, values, calldatas, descriptionHash);
-    }
-
-    function _cancel(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
-        internal
-        override(Governor, GovernorTimelockControl)
-        returns (uint256)
-    {
-        return super._cancel(targets, values, calldatas, descriptionHash);
-    }
-
-    function _executor()
-        internal
-        view
-        override(Governor, GovernorTimelockControl)
-        returns (address)
-    {
-        return super._executor();
-    }
-
-    function supportsInterface(bytes4 interfaceId)
-        public
-        view
-        override(Governor, GovernorTimelockControl)
-        returns (bool)
-    {
-        return super.supportsInterface(interfaceId);
-    }
-}

certora/harnesses/WizardFirstTry.sol

@@ -1,141 +0,0 @@
-// SPDX-License-Identifier: MIT
-pragma solidity ^0.8.2;
-
-import "../munged/governance/Governor.sol";
-import "../munged/governance/extensions/GovernorCountingSimple.sol";
-import "../munged/governance/extensions/GovernorVotes.sol";
-import "../munged/governance/extensions/GovernorVotesQuorumFraction.sol";
-import "../munged/governance/extensions/GovernorTimelockCompound.sol";
-
-/* 
-Wizard options:
-ERC20Votes
-TimelockCompound
-*/
-
-contract WizardFirstTry is Governor, GovernorCountingSimple, GovernorVotes, GovernorVotesQuorumFraction, GovernorTimelockCompound {
-    constructor(ERC20Votes _token, ICompoundTimelock _timelock, string memory name, uint256 quorumFraction)
-        Governor(name)
-        GovernorVotes(_token)
-        GovernorVotesQuorumFraction(quorumFraction)
-        GovernorTimelockCompound(_timelock)
-    {}
-
-    //HARNESS
-
-    function isExecuted(uint256 proposalId) public view returns (bool) {
-        return _proposals[proposalId].executed;
-    }
-    
-    function isCanceled(uint256 proposalId) public view returns (bool) {
-        return _proposals[proposalId].canceled;
-    }
-
-    function snapshot(uint256 proposalId) public view returns (uint64) {
-        return _proposals[proposalId].voteStart._deadline;
-    }
-
-    function getExecutor() public view returns (address){
-        return _executor();
-    }
-
-    uint256 _votingDelay;
-
-    uint256 _votingPeriod;
-
-    mapping(uint256 => uint256) public ghost_sum_vote_power_by_id;
-
-    function _castVote(
-        uint256 proposalId,
-        address account,
-        uint8 support,
-        string memory reason
-    ) internal override virtual returns (uint256) {
-        
-        uint256 deltaWeight = super._castVote(proposalId, account, support, reason);  //HARNESS
-        ghost_sum_vote_power_by_id[proposalId] += deltaWeight;
-
-        return deltaWeight;        
-    }
-
-    // original code, harnessed
-
-    function votingDelay() public view override virtual returns (uint256) {     // HARNESS: pure -> view
-        return _votingDelay;                                                    // HARNESS: parametric
-    }
-
-    function votingPeriod() public view override virtual returns (uint256) {    // HARNESS: pure -> view
-        return _votingPeriod;                                                   // HARNESS: parametric
-    }
-
-    // original code, not harnessed
-    // The following functions are overrides required by Solidity.
-
-    function quorum(uint256 blockNumber)
-        public
-        view
-        override(IGovernor, GovernorVotesQuorumFraction)
-        returns (uint256)
-    {
-        return super.quorum(blockNumber);
-    }
-
-    function getVotes(address account, uint256 blockNumber)
-        public
-        view
-        override(IGovernor, GovernorVotes)
-        returns (uint256)
-    {
-        return super.getVotes(account, blockNumber);
-    }
-
-    function state(uint256 proposalId)
-        public
-        view
-        override(Governor, GovernorTimelockCompound)
-        returns (ProposalState)
-    {
-        return super.state(proposalId);
-    }
-
-    function propose(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, string memory description)
-        public
-        override(Governor, IGovernor)
-        returns (uint256)
-    {
-        return super.propose(targets, values, calldatas, description);
-    }
-
-    function _execute(uint256 proposalId, address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
-        internal
-        override(Governor, GovernorTimelockCompound)
-    {
-        super._execute(proposalId, targets, values, calldatas, descriptionHash);
-    }
-
-    function _cancel(address[] memory targets, uint256[] memory values, bytes[] memory calldatas, bytes32 descriptionHash)
-        internal
-        override(Governor, GovernorTimelockCompound)
-        returns (uint256)
-    {
-        return super._cancel(targets, values, calldatas, descriptionHash);
-    }
-
-    function _executor()
-        internal
-        view
-        override(Governor, GovernorTimelockCompound)
-        returns (address)
-    {
-        return super._executor();
-    }
-
-    function supportsInterface(bytes4 interfaceId)
-        public
-        view
-        override(Governor, GovernorTimelockCompound)
-        returns (bool)
-    {
-        return super.supportsInterface(interfaceId);
-    }
-}

certora/munged/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore

certora/scripts/Governor.sh

@@ -1,10 +0,0 @@
-make -C certora munged
-
-certoraRun certora/harnesses/ERC20VotesHarness.sol certora/harnesses/GovernorHarness.sol \
-    --verify GovernorHarness:certora/specs/GovernorBase.spec \
-    --solc solc8.0 \
-    --staging shelly/forSasha \
-    --optimistic_loop \
-    --settings -copyLoopUnroll=4 \
-    --rule voteStartBeforeVoteEnd \
-    --msg "$1"

certora/scripts/GovernorCountingSimple-counting.sh

@@ -1,10 +0,0 @@
-make -C certora munged
-
-certoraRun  certora/harnesses/ERC20VotesHarness.sol certora/harnesses/GovernorBasicHarness.sol \
-    --verify GovernorBasicHarness:certora/specs/GovernorCountingSimple.spec \
-    --solc solc8.2 \
-    --staging shelly/forSasha \
-    --optimistic_loop \
-    --settings -copyLoopUnroll=4 \
-    --rule hasVotedCorrelation \
-    --msg "$1"

certora/scripts/WizardControlFirstPriority.sh

@@ -1,12 +0,0 @@
-make -C certora munged
-
-certoraRun certora/harnesses/ERC20VotesHarness.sol certora/harnesses/WizardControlFirstPriority.sol \
-    --link WizardControlFirstPriority:token=ERC20VotesHarness \
-    --verify WizardControlFirstPriority:certora/specs/GovernorBase.spec \
-    --solc solc8.2 \
-    --disableLocalTypeChecking \
-    --staging shelly/forSasha \
-    --optimistic_loop \
-    --settings -copyLoopUnroll=4 \
-    --rule canVoteDuringVotingPeriod \
-    --msg "$1"

certora/scripts/WizardFirstTry.sh

@@ -1,10 +0,0 @@
-make -C certora munged
-
-certoraRun certora/harnesses/ERC20VotesHarness.sol certora/harnesses/WizardFirstTry.sol \
-    --verify WizardFirstTry:certora/specs/GovernorBase.spec \
-    --solc solc8.2 \
-    --staging shelly/forSasha \
-    --optimistic_loop \
-    --disableLocalTypeChecking \
-    --settings -copyLoopUnroll=4 \
-    --msg "$1"

certora/scripts/sanity.sh

@@ -1,14 +0,0 @@
-make -C certora munged
-
-for f in certora/harnesses/Wizard*.sol
-do
-    echo "Processing $f"
-    file=$(basename $f)
-    echo ${file%.*}
-    certoraRun certora/harnesses/$file \
-    --verify ${file%.*}:certora/specs/sanity.spec "$@" \
-    --solc solc8.2 --staging shelly/forSasha \
-    --optimistic_loop \
-    --msg "checking sanity on ${file%.*}"
-    --settings -copyLoopUnroll=4
-done

certora/scripts/verifyAll.sh

@@ -1,39 +0,0 @@
-#!/bin/bash
-
-make -C certora munged
-
-for contract in certora/harnesses/Wizard*.sol;
-do
-    for spec in certora/specs/*.spec;
-    do      
-        contractFile=$(basename $contract)
-        specFile=$(basename $spec)
-        if [[ "${specFile%.*}" != "RulesInProgress" ]];
-        then
-            echo "Processing ${contractFile%.*} with $specFile"
-            if [[ "${contractFile%.*}" = *"WizardControl"* ]];
-            then
-                certoraRun certora/harnesses/ERC20VotesHarness.sol certora/harnesses/$contractFile \
-                --link ${contractFile%.*}:token=ERC20VotesHarness \
-                --verify ${contractFile%.*}:certora/specs/$specFile "$@" \
-                --solc solc8.2 \
-                --staging shelly/forSasha \
-                --disableLocalTypeChecking \
-                --optimistic_loop \
-                --settings -copyLoopUnroll=4 \
-                --send_only \
-                --msg "checking $specFile on ${contractFile%.*}"
-            else
-                certoraRun certora/harnesses/ERC20VotesHarness.sol certora/harnesses/$contractFile \
-                --verify ${contractFile%.*}:certora/specs/$specFile "$@" \
-                --solc solc8.2 \
-                --staging shelly/forSasha \
-                --disableLocalTypeChecking \
-                --optimistic_loop \
-                --settings -copyLoopUnroll=4 \
-                --send_only \
-                --msg "checking $specFile on ${contractFile%.*}"
-            fi
-        fi
-    done
-done

certora/specs/GovernorBase.spec

@@ -1,333 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-///////////////////// Governor.sol base definitions //////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-using ERC20VotesHarness as erc20votes
-
-methods {
-    proposalSnapshot(uint256) returns uint256 envfree // matches proposalVoteStart
-    proposalDeadline(uint256) returns uint256 envfree // matches proposalVoteEnd
-    hashProposal(address[],uint256[],bytes[],bytes32) returns uint256 envfree
-    isExecuted(uint256) returns bool envfree
-    isCanceled(uint256) returns bool envfree
-    execute(address[], uint256[], bytes[], bytes32) returns uint256
-    hasVoted(uint256, address) returns bool
-    castVote(uint256, uint8) returns uint256
-    updateQuorumNumerator(uint256)
-    queue(address[], uint256[], bytes[], bytes32) returns uint256
-
-    // internal functions made public in harness:
-    _quorumReached(uint256) returns bool
-    _voteSucceeded(uint256) returns bool envfree
-
-    // function summarization
-    proposalThreshold() returns uint256 envfree
-
-    getVotes(address, uint256) returns uint256 => DISPATCHER(true)
-
-    getPastTotalSupply(uint256 t) returns uint256      => PER_CALLEE_CONSTANT
-    getPastVotes(address a, uint256 t) returns uint256 => PER_CALLEE_CONSTANT
-
-    //scheduleBatch(address[],uint256[],bytes[],bytes32,bytes32,uint256) => DISPATCHER(true)
-    //executeBatch(address[], uint256[], bytes[], bytes32, bytes32) => DISPATCHER(true)
-}
-
-//////////////////////////////////////////////////////////////////////////////
-//////////////////////////////// Definitions /////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-// proposal was created - relation proved in noStartBeforeCreation
-definition proposalCreated(uint256 pId) returns bool = proposalSnapshot(pId) > 0;
-
-
-//////////////////////////////////////////////////////////////////////////////
-///////////////////////////// Helper Functions ///////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-function helperFunctionsWithRevert(uint256 proposalId, method f, env e) {
-    address[] targets; uint256[] values; bytes[] calldatas; string reason; bytes32 descriptionHash;
-    uint8 support; uint8 v; bytes32 r; bytes32 s;
-	if (f.selector == propose(address[], uint256[], bytes[], string).selector) {
-		uint256 result = propose@withrevert(e, targets, values, calldatas, reason);
-        require(result == proposalId);
-	} else if (f.selector == execute(address[], uint256[], bytes[], bytes32).selector) {
-		uint256 result = execute@withrevert(e, targets, values, calldatas, descriptionHash);
-        require(result == proposalId);
-	} else if (f.selector == castVote(uint256, uint8).selector) {
-		castVote@withrevert(e, proposalId, support);
-	} else if  (f.selector == castVoteWithReason(uint256, uint8, string).selector) {
-        castVoteWithReason@withrevert(e, proposalId, support, reason);
-	} else if (f.selector == castVoteBySig(uint256, uint8,uint8, bytes32, bytes32).selector) {
-		castVoteBySig@withrevert(e, proposalId, support, v, r, s);
-    } else if (f.selector == queue(address[], uint256[], bytes[], bytes32).selector) {
-        queue@withrevert(e, targets, values, calldatas, descriptionHash);
-	} else {
-        calldataarg args;
-        f@withrevert(e, args);
-    }
-}
-
-/*
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- ///////////////////////////////////////////////////// State Diagram //////////////////////////////////////////////////////////
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
- //                                                                                                                          //
- //                                                                castVote(s)()                                             //
- //  -------------  propose()  ----------------------  time pass  ---------------       time passes         -----------      //
- // | No Proposal | --------> | Before Start (Delay) | --------> | Voting Period | ----------------------> | execute() |     //
- //  -------------             ----------------------             --------------- -> Executed/Canceled      -----------      //
- //  ------------------------------------------------------------|---------------|-------------------------|-------------->  //
- // t                                                          start            end                     timelock             //
- //                                                                                                                          //
- //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-*/
-
-
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////// Global Valid States /////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
-
-
-/*
- * Start and end date are either initialized (non zero) or uninitialized (zero) simultaneously
- * This invariant assumes that the block number cannot be 0 at any stage of the contract cycle
- * This is very safe assumption as usually the 0 block is genesis block which is uploaded with data
- * by the developers and will not be valid to raise proposals (at the current way that block chain is functioning)
- */
- // To use env with general preserved block disable type checking [--disableLocalTypeChecking]
-invariant startAndEndDatesNonZero(uint256 pId)
-        proposalSnapshot(pId) != 0 <=> proposalDeadline(pId) != 0
-        { preserved with (env e){
-                require e.block.number > 0;
-        }}
-
-
-/*
- * If a proposal is canceled it must have a start and an end date
- */
- // To use env with general preserved block disable type checking [--disableLocalTypeChecking]
-invariant canceledImplyStartAndEndDateNonZero(uint pId)
-        isCanceled(pId) => proposalSnapshot(pId) != 0
-        {preserved with (env e){
-                require e.block.number > 0;
-        }}
-
-
-/*
- * If a proposal is executed it must have a start and an end date
- */
- // To use env with general preserved block disable type checking [--disableLocalTypeChecking]
-invariant executedImplyStartAndEndDateNonZero(uint pId)
-        isExecuted(pId) => proposalSnapshot(pId) != 0
-        { preserved with (env e){
-            requireInvariant startAndEndDatesNonZero(pId);
-            require e.block.number > 0;
-        }}
-
-
-/*
- * A proposal starting block number must be less or equal than the proposal end date
- */
-invariant voteStartBeforeVoteEnd(uint256 pId)
-        // from < to <= because snapshot and deadline can be the same block number if delays are set to 0
-        // This is possible before the integration of GovernorSettings.sol to the system.
-        // After integration of GovernorSettings.sol the invariant expression should be changed from <= to <
-        (proposalSnapshot(pId) > 0 =>  proposalSnapshot(pId) <= proposalDeadline(pId))
-        // (proposalSnapshot(pId) > 0 =>  proposalSnapshot(pId) <= proposalDeadline(pId))
-        { preserved {
-            requireInvariant startAndEndDatesNonZero(pId);
-        }}
-
-
-/*
- * A proposal cannot be both executed and canceled simultaneously.
- */
-invariant noBothExecutedAndCanceled(uint256 pId)
-        !isExecuted(pId) || !isCanceled(pId)
-
-
-/*
- * A proposal could be executed only if quorum was reached and vote succeeded
- */
-rule executionOnlyIfQuoromReachedAndVoteSucceeded(uint256 pId, env e, method f){
-    bool isExecutedBefore = isExecuted(pId);
-    bool quorumReachedBefore = _quorumReached(e, pId);
-    bool voteSucceededBefore = _voteSucceeded(pId);
-
-    calldataarg args;
-    f(e, args);
-
-    bool isExecutedAfter = isExecuted(pId);
-    assert (!isExecutedBefore && isExecutedAfter) => (quorumReachedBefore && voteSucceededBefore), "quorum was changed";
-}
-
-///////////////////////////////////////////////////////////////////////////////////////
-////////////////////////////////// In-State Rules /////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
-
-//==========================================
-//------------- Voting Period --------------
-//==========================================
-
-/*
- * A user cannot vote twice
- */
- // Checked for castVote only. all 3 castVote functions call _castVote, so the completeness of the verification is counted on
- // the fact that the 3 functions themselves makes no changes, but rather call an internal function to execute.
- // That means that we do not check those 3 functions directly, however for castVote & castVoteWithReason it is quite trivial
- // to understand why this is ok. For castVoteBySig we basically assume that the signature referendum is correct without checking it.
- // We could check each function separately and pass the rule, but that would have uglyfied the code with no concrete
- // benefit, as it is evident that nothing is happening in the first 2 functions (calling a view function), and we do not desire to check the signature verification.
-rule doubleVoting(uint256 pId, uint8 sup, method f) {
-    env e;
-    address user = e.msg.sender;
-    bool votedCheck = hasVoted(e, pId, user);
-
-    castVote@withrevert(e, pId, sup);
-
-    assert votedCheck => lastReverted, "double voting occurred";
-}
-
-
-///////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////// State Transitions Rules //////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
-
-//===========================================
-//-------- Propose() --> End of Time --------
-//===========================================
-
-
-/*
- * Once a proposal is created, voteStart and voteEnd are immutable
- */
-rule immutableFieldsAfterProposalCreation(uint256 pId, method f) {
-    uint256 _voteStart = proposalSnapshot(pId);
-    uint256 _voteEnd = proposalDeadline(pId);
-
-    require proposalCreated(pId); // startDate > 0
-
-    env e; calldataarg arg;
-    f(e, arg);
-
-    uint256 voteStart_ = proposalSnapshot(pId);
-    uint256 voteEnd_ = proposalDeadline(pId);
-    assert _voteStart == voteStart_, "Start date was changed";
-    assert _voteEnd == voteEnd_, "End date was changed";
-}
-
-
-/*
- * Voting cannot start at a block number prior to proposal’s creation block number
- */
-rule noStartBeforeCreation(uint256 pId) {
-    uint256 previousStart = proposalSnapshot(pId);
-    // This line makes sure that we see only cases where start date is changed from 0, i.e. creation of proposal
-    // We proved in immutableFieldsAfterProposalCreation that once dates set for proposal, it cannot be changed
-    require !proposalCreated(pId); // previousStart == 0;
-
-    env e; calldataarg args;
-    propose(e, args);
-
-    uint256 newStart = proposalSnapshot(pId);
-    // if created, start is after current block number (creation block)
-    assert(newStart != previousStart => newStart >= e.block.number);
-}
-
-
-//============================================
-//--- End of Voting Period --> End of Time ---
-//============================================
-
-
-/*
- * A proposal can neither be executed nor canceled before it ends
- */
- // By induction it cannot be executed nor canceled before it starts, due to voteStartBeforeVoteEnd
-rule noExecuteOrCancelBeforeDeadline(uint256 pId, method f){
-    require !isExecuted(pId) && !isCanceled(pId);
-
-    env e; calldataarg args;
-    f(e, args);
-
-    assert e.block.number < proposalDeadline(pId) => (!isExecuted(pId) && !isCanceled(pId)), "executed/cancelled before deadline";
-}
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////// Integrity Of Functions (Unit Tests) /////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////
-////////////////////////////// High Level Rules ////////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-////////////////////////////////////////////////////////////////////////////////
-///////////////////////////// Not Categorized Yet //////////////////////////////
-////////////////////////////////////////////////////////////////////////////////
-
-
-/*
- * All proposal specific (non-view) functions should revert if proposal is executed
- */
- // In this rule we show that if a function is executed, i.e. execute() was called on the proposal ID,
- // non of the proposal specific functions can make changes again. In executedOnlyAfterExecuteFunc
- // we connected the executed attribute to the execute() function, showing that only execute() can
- // change it, and that it will always change it.
-rule allFunctionsRevertIfExecuted(method f) filtered { f ->
-    !f.isView && !f.isFallback
-      && f.selector != updateTimelock(address).selector
-      && f.selector != updateQuorumNumerator(uint256).selector
-      && f.selector != queue(address[],uint256[],bytes[],bytes32).selector
-      && f.selector != relay(address,uint256,bytes).selector
-      && f.selector != 0xb9a61961 // __acceptAdmin()
-} {
-    env e; calldataarg args;
-    uint256 pId;
-    require(isExecuted(pId));
-    requireInvariant noBothExecutedAndCanceled(pId);
-    requireInvariant executedImplyStartAndEndDateNonZero(pId);
-
-    helperFunctionsWithRevert(pId, f, e);
-
-    assert(lastReverted, "Function was not reverted");
-}
-
-/*
- * All proposal specific (non-view) functions should revert if proposal is canceled
- */
-rule allFunctionsRevertIfCanceled(method f) filtered {
-    f -> !f.isView && !f.isFallback
-      && f.selector != updateTimelock(address).selector
-      && f.selector != updateQuorumNumerator(uint256).selector
-      && f.selector != queue(address[],uint256[],bytes[],bytes32).selector
-      && f.selector != relay(address,uint256,bytes).selector
-      && f.selector != 0xb9a61961 // __acceptAdmin()
-} {
-    env e; calldataarg args;
-    uint256 pId;
-    require(isCanceled(pId));
-    requireInvariant noBothExecutedAndCanceled(pId);
-    requireInvariant canceledImplyStartAndEndDateNonZero(pId);
-
-    helperFunctionsWithRevert(pId, f, e);
-
-    assert(lastReverted, "Function was not reverted");
-}
-
-/*
- * Proposal can be switched to executed only via execute() function
- */
-rule executedOnlyAfterExecuteFunc(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash, method f) {
-    env e; calldataarg args;
-    uint256 pId;
-    bool executedBefore = isExecuted(pId);
-    require(!executedBefore);
-
-    helperFunctionsWithRevert(pId, f, e);
-
-    bool executedAfter = isExecuted(pId);
-    assert(executedAfter != executedBefore => f.selector == execute(address[], uint256[], bytes[], bytes32).selector, "isExecuted only changes in the execute method");
-}

certora/specs/GovernorCountingSimple.spec

@@ -1,221 +0,0 @@
-import "GovernorBase.spec"
-
-using ERC20VotesHarness as erc20votes
-
-methods {
-    ghost_sum_vote_power_by_id(uint256) returns uint256 envfree
-
-    quorum(uint256) returns uint256
-    proposalVotes(uint256) returns (uint256, uint256, uint256) envfree
-
-    quorumNumerator() returns uint256
-    _executor() returns address
-
-    erc20votes._getPastVotes(address, uint256) returns uint256
-
-    getExecutor() returns address
-
-    timelock() returns address
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-///////////////////////////////// GHOSTS /////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-//////////// ghosts to keep track of votes counting ////////////
-
-/*
- * the sum of voting power of those who voted
- */
-ghost sum_all_votes_power() returns uint256 {
-	init_state axiom sum_all_votes_power() == 0;
-}
-
-hook Sstore ghost_sum_vote_power_by_id [KEY uint256 pId] uint256 current_power(uint256 old_power) STORAGE {
-	havoc sum_all_votes_power assuming sum_all_votes_power@new() == sum_all_votes_power@old() - old_power + current_power;
-}
-
-/*
- * sum of all votes casted per proposal
- */
-ghost tracked_weight(uint256) returns uint256 {
-	init_state axiom forall uint256 p. tracked_weight(p) == 0;
-}
-
-/*
- * sum of all votes casted
- */
-ghost sum_tracked_weight() returns uint256 {
-	init_state axiom sum_tracked_weight() == 0;
-}
-
-/*
- * getter for _proposalVotes.againstVotes
- */
-ghost votesAgainst() returns uint256 {
-    init_state axiom votesAgainst() == 0;
-}
-
-/*
- * getter for _proposalVotes.forVotes
- */
-ghost votesFor() returns uint256 {
-    init_state axiom votesFor() == 0;
-}
-
-/*
- * getter for _proposalVotes.abstainVotes
- */
-ghost votesAbstain() returns uint256 {
-    init_state axiom votesAbstain() == 0;
-}
-
-hook Sstore _proposalVotes [KEY uint256 pId].againstVotes uint256 votes(uint256 old_votes) STORAGE {
-	havoc tracked_weight assuming forall uint256 p.(p == pId => tracked_weight@new(p) == tracked_weight@old(p) - old_votes + votes) &&
-	                                            (p != pId => tracked_weight@new(p) == tracked_weight@old(p));
-	havoc sum_tracked_weight assuming sum_tracked_weight@new() == sum_tracked_weight@old() - old_votes + votes;
-    havoc votesAgainst assuming votesAgainst@new() == votesAgainst@old() - old_votes + votes;
-}
-
-hook Sstore _proposalVotes [KEY uint256 pId].forVotes uint256 votes(uint256 old_votes) STORAGE {
-	havoc tracked_weight assuming forall uint256 p.(p == pId => tracked_weight@new(p) == tracked_weight@old(p) - old_votes + votes) &&
-	                                            (p != pId => tracked_weight@new(p) == tracked_weight@old(p));
-	havoc sum_tracked_weight assuming sum_tracked_weight@new() == sum_tracked_weight@old() - old_votes + votes;
-    havoc votesFor assuming votesFor@new() == votesFor@old() - old_votes + votes;
-}
-
-hook Sstore _proposalVotes [KEY uint256 pId].abstainVotes uint256 votes(uint256 old_votes) STORAGE {
-	havoc tracked_weight assuming forall uint256 p.(p == pId => tracked_weight@new(p) == tracked_weight@old(p) - old_votes + votes) &&
-	                                            (p != pId => tracked_weight@new(p) == tracked_weight@old(p));
-	havoc sum_tracked_weight assuming sum_tracked_weight@new() == sum_tracked_weight@old() - old_votes + votes;
-    havoc votesAbstain assuming votesAbstain@new() == votesAbstain@old() - old_votes + votes;
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-////////////////////////////// INVARIANTS ////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-/*
- * sum of all votes casted is equal to the sum of voting power of those who voted, per each proposal
- */
-invariant SumOfVotesCastEqualSumOfPowerOfVotedPerProposal(uint256 pId) 
-	tracked_weight(pId) == ghost_sum_vote_power_by_id(pId)
-
-
-/*
- * sum of all votes casted is equal to the sum of voting power of those who voted
- */
-invariant SumOfVotesCastEqualSumOfPowerOfVoted() 
-	sum_tracked_weight() == sum_all_votes_power()
-
-
-/*
-* sum of all votes casted is greater or equal to the sum of voting power of those who voted at a specific proposal
-*/
-invariant OneIsNotMoreThanAll(uint256 pId) 
-	sum_all_votes_power() >= tracked_weight(pId)
-
-
-//////////////////////////////////////////////////////////////////////////////
-///////////////////////////////// RULES //////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-/*
- * Only sender's voting status can be changed by execution of any cast vote function
- */
-// Checked for castVote only. all 3 castVote functions call _castVote, so the completeness of the verification is counted on
- // the fact that the 3 functions themselves makes no changes, but rather call an internal function to execute.
- // That means that we do not check those 3 functions directly, however for castVote & castVoteWithReason it is quite trivial
- // to understand why this is ok. For castVoteBySig we basically assume that the signature referendum is correct without checking it.
- // We could check each function separately and pass the rule, but that would have uglyfied the code with no concrete 
- // benefit, as it is evident that nothing is happening in the first 2 functions (calling a view function), and we do not desire to check the signature verification.
-rule noVoteForSomeoneElse(uint256 pId, uint8 sup, method f) {
-    env e; calldataarg args;
-
-    address voter = e.msg.sender;
-    address user;
-
-    bool hasVotedBefore_User = hasVoted(e, pId, user);
-
-    castVote@withrevert(e, pId, sup);
-    require(!lastReverted);
-
-    bool hasVotedAfter_User = hasVoted(e, pId, user);
-
-    assert user != voter => hasVotedBefore_User == hasVotedAfter_User;
-}
-
-
-/*
-* Total voting tally is monotonically non-decreasing in every operation 
-*/
-rule votingWeightMonotonicity(method f){
-    uint256 votingWeightBefore = sum_tracked_weight();
-
-    env e; 
-    calldataarg args;
-    f(e, args);
-
-    uint256 votingWeightAfter = sum_tracked_weight();
-
-    assert votingWeightBefore <= votingWeightAfter, "Voting weight was decreased somehow";
-}
-
-
-/*
-* A change in hasVoted must be correlated with an non-decreasing of the vote supports (nondecrease because user can vote with weight 0)
-*/
-rule hasVotedCorrelation(uint256 pId, method f, env e, uint256 bn) {
-    address acc = e.msg.sender;
-    
-    uint256 againstBefore = votesAgainst();
-    uint256 forBefore = votesFor();
-    uint256 abstainBefore = votesAbstain();
-
-    bool hasVotedBefore = hasVoted(e, pId, acc);
-
-    helperFunctionsWithRevert(pId, f, e);
-    require(!lastReverted);
-
-    uint256 againstAfter = votesAgainst();
-    uint256 forAfter = votesFor();
-    uint256 abstainAfter = votesAbstain();
-    
-    bool hasVotedAfter = hasVoted(e, pId, acc);
-
-    assert (!hasVotedBefore && hasVotedAfter) => againstBefore <= againstAfter || forBefore <= forAfter || abstainBefore <= abstainAfter, "no correlation";
-}
-
-
-/*
-* Only privileged users can execute privileged operations, e.g. change _quorumNumerator or _timelock
-*/
-rule privilegedOnlyNumerator(method f, uint256 newQuorumNumerator){
-    env e;
-    calldataarg arg;
-    uint256 quorumNumBefore = quorumNumerator(e);
-
-    f(e, arg);
-
-    uint256 quorumNumAfter = quorumNumerator(e);
-    address executorCheck = getExecutor(e);
-
-    assert quorumNumBefore != quorumNumAfter => e.msg.sender == executorCheck, "non privileged user changed quorum numerator";
-}
-
-rule privilegedOnlyTimelock(method f, uint256 newQuorumNumerator){
-    env e;
-    calldataarg arg;
-    uint256 timelockBefore = timelock(e);
-
-    f(e, arg);
-
-    uint256 timelockAfter = timelock(e);
-
-    assert timelockBefore != timelockAfter => e.msg.sender == timelockBefore, "non privileged user changed timelock";
-}

certora/specs/RulesInProgress.spec

@@ -1,139 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-////////////// THIS SPEC IS A RESERVE FOR NOT IN PROGRESS //////////////
-//////////////////////////////////////////////////////////////////////////////
-
-import "GovernorBase.spec"
-
-using ERC20VotesHarness as erc20votes
-
-methods {
-    ghost_sum_vote_power_by_id(uint256) returns uint256 envfree
-
-    quorum(uint256) returns uint256
-    proposalVotes(uint256) returns (uint256, uint256, uint256) envfree
-
-    quorumNumerator() returns uint256
-    _executor() returns address
-
-    erc20votes._getPastVotes(address, uint256) returns uint256
-
-    getExecutor() returns address
-
-    timelock() returns address
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-///////////////////////////////// GHOSTS /////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-//////////// ghosts to keep track of votes counting ////////////
-
-/*
- * the sum of voting power of those who voted
- */
-ghost sum_all_votes_power() returns uint256 {
-	init_state axiom sum_all_votes_power() == 0;
-}
-
-hook Sstore ghost_sum_vote_power_by_id [KEY uint256 pId] uint256 current_power(uint256 old_power) STORAGE {
-	havoc sum_all_votes_power assuming sum_all_votes_power@new() == sum_all_votes_power@old() - old_power + current_power;
-}
-
-/*
- * sum of all votes casted per proposal
- */
-ghost tracked_weight(uint256) returns uint256 {
-	init_state axiom forall uint256 p. tracked_weight(p) == 0;
-}
-
-/*
- * sum of all votes casted
- */
-ghost sum_tracked_weight() returns uint256 {
-	init_state axiom sum_tracked_weight() == 0;
-}
-
-/*
- * getter for _proposalVotes.againstVotes
- */
-ghost votesAgainst() returns uint256 {
-    init_state axiom votesAgainst() == 0;
-}
-
-/*
- * getter for _proposalVotes.forVotes
- */
-ghost votesFor() returns uint256 {
-    init_state axiom votesFor() == 0;
-}
-
-/*
- * getter for _proposalVotes.abstainVotes
- */
-ghost votesAbstain() returns uint256 {
-    init_state axiom votesAbstain() == 0;
-}
-
-hook Sstore _proposalVotes [KEY uint256 pId].againstVotes uint256 votes(uint256 old_votes) STORAGE {
-	havoc tracked_weight assuming forall uint256 p.(p == pId => tracked_weight@new(p) == tracked_weight@old(p) - old_votes + votes) &&
-	                                            (p != pId => tracked_weight@new(p) == tracked_weight@old(p));
-	havoc sum_tracked_weight assuming sum_tracked_weight@new() == sum_tracked_weight@old() - old_votes + votes;
-    havoc votesAgainst assuming votesAgainst@new() == votesAgainst@old() - old_votes + votes;
-}
-
-hook Sstore _proposalVotes [KEY uint256 pId].forVotes uint256 votes(uint256 old_votes) STORAGE {
-	havoc tracked_weight assuming forall uint256 p.(p == pId => tracked_weight@new(p) == tracked_weight@old(p) - old_votes + votes) &&
-	                                            (p != pId => tracked_weight@new(p) == tracked_weight@old(p));
-	havoc sum_tracked_weight assuming sum_tracked_weight@new() == sum_tracked_weight@old() - old_votes + votes;
-    havoc votesFor assuming votesFor@new() == votesFor@old() - old_votes + votes;
-}
-
-hook Sstore _proposalVotes [KEY uint256 pId].abstainVotes uint256 votes(uint256 old_votes) STORAGE {
-	havoc tracked_weight assuming forall uint256 p.(p == pId => tracked_weight@new(p) == tracked_weight@old(p) - old_votes + votes) &&
-	                                            (p != pId => tracked_weight@new(p) == tracked_weight@old(p));
-	havoc sum_tracked_weight assuming sum_tracked_weight@new() == sum_tracked_weight@old() - old_votes + votes;
-    havoc votesAbstain assuming votesAbstain@new() == votesAbstain@old() - old_votes + votes;
-}
-
-
-//////////////////////////////////////////////////////////////////////////////
-////////////////////////////// INVARIANTS ////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-
-//////////////////////////////////////////////////////////////////////////////
-///////////////////////////////// RULES //////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////
-
-
-//NOT FINISHED
-/*
-* the sum of voting power of those who voted is less or equal to the maximum possible votes, per each proposal
-*/
-rule possibleTotalVotes(uint256 pId, uint8 sup, env e, method f) {
-
-    // add requireinvariant  for all i, j. i = i - 1 && i < j => checkpointlookup[i] < checkpointlookup[j];
-    require tracked_weight(pId) <= erc20votes.getPastTotalSupply(e, proposalSnapshot(pId));
-
-    uint256 againstB;
-    uint256 forB;
-    uint256 absatinB;
-    againstB, forB, absatinB = proposalVotes(pId);
-
-    calldataarg args;
-    //f(e, args);
-
-    castVote(e, pId, sup);
-
-    uint256 against;
-    uint256 for;
-    uint256 absatin;
-    against, for, absatin = proposalVotes(pId);
-
-    uint256 ps = proposalSnapshot(pId);
-
-    assert tracked_weight(pId) <= erc20votes.getPastTotalSupply(e, proposalSnapshot(pId)), "bla bla bla";
-}

certora/specs/sanity.spec

@@ -1,14 +0,0 @@
-/*
-This rule looks for a non-reverting execution path to each method, including those overridden in the harness.
-A method has such an execution path if it violates this rule.
-How it works:
-    - If there is a non-reverting execution path, we reach the false assertion, and the sanity fails.
-    - If all execution paths are reverting, we never call the assertion, and the method will pass this rule vacuously.
-*/
-	
-rule sanity(method f) {
-    env e;
-    calldataarg arg;
-    f(e, arg);
-    assert false;
-}

contracts/ARCHITECTURE.md

@@ -0,0 +1,27 @@
+## Architecture
+
+The following provides visibility into how OpenZeppelin's contracts are organized:
+
+- **access** - Smart contracts that enable functionality that can be used for selective restrictions and basic authorization control functions.
+- **crowdsale** - A collection of smart contracts used to manage token crowdsales that allow investors to purchase tokens with ETH. Includes a base contract which implements fundamental crowdsale functionality in its simplest form. The base contract can be extended in order to satisfy your crowdsale’s specific requirements.
+	- **distribution** - Includes extensions of the base crowdsale contract which can be used to customize the completion of a crowdsale.
+	- **emission** - Includes extensions of the base crowdsale contract which can be used to mint and manage how tokens are issued to purchasers.
+	- **price** - Includes extensions of the crowdsale contract that can be used to manage changes in token prices.
+	- **validation**  - Includes extensions of the crowdsale contract that can be used to enforce restraints and limit access to token purchases.
+- **examples** - A collection of simple smart contracts that demonstrate how to add new features to base contracts through multiple inheritance.
+- **introspection**  - An interface that can be used to make a contract comply with the ERC-165 standard as well as a contract that implements ERC-165 using a lookup table.
+- **lifecycle** - A collection of base contracts used to manage the existence and behavior of your contracts and their funds.
+- **math** - Libraries with safety checks on operations that throw on errors.
+- **mocks** - A collection of abstract contracts that are primarily used for unit testing. They also serve as good usage examples and demonstrate how to combine contracts with inheritance when developing your own custom applications.
+- **ownership** - A collection of smart contracts that can be used to manage contract and token ownership
+- **payment** - A collection of smart contracts that can be used to manage payments through escrow arrangements, withdrawals, and claims. Includes support for both single payees and multiple payees.
+- **proposals** - A collection of smart contracts that reflect community Ethereum Improvement Proposals (EIPs). These contracts are under development and standardization. They are not recommended for production, but they are useful for experimentation with pending EIP standards. Go [here](https://github.com/OpenZeppelin/openzeppelin-solidity/wiki/ERC-Process) for more information.
+
+- **token** - A collection of approved ERC standard tokens -- their interfaces and implementations.
+	- **ERC20** - A standard interface for fungible tokens:
+		- *Interfaces* - Includes the ERC-20 token standard basic interface. I.e., what the contract’s ABI can represent.
+		- *Implementations* - Includes ERC-20 token implementations that include all required and some optional ERC-20 functionality.
+	- **ERC721** - A standard interface for non-fungible tokens
+		- *Interfaces* - Includes the ERC-721 token standard basic interface. I.e., what the contract’s ABI can represent.
+		- *Implementations* - Includes ERC-721 token implementations that include all required and some optional ERC-721 functionality.
+

contracts/access/AccessControl.sol

@@ -1,247 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)
-
-pragma solidity ^0.8.0;
-
-import "./IAccessControl.sol";
-import "../utils/Context.sol";
-import "../utils/Strings.sol";
-import "../utils/introspection/ERC165.sol";
-
-/**
- * @dev Contract module that allows children to implement role-based access
- * control mechanisms. This is a lightweight version that doesn't allow enumerating role
- * members except through off-chain means by accessing the contract event logs. Some
- * applications may benefit from on-chain enumerability, for those cases see
- * {AccessControlEnumerable}.
- *
- * Roles are referred to by their `bytes32` identifier. These should be exposed
- * in the external API and be unique. The best way to achieve this is by
- * using `public constant` hash digests:
- *
- * ```
- * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
- * ```
- *
- * Roles can be used to represent a set of permissions. To restrict access to a
- * function call, use {hasRole}:
- *
- * ```
- * function foo() public {
- *     require(hasRole(MY_ROLE, msg.sender));
- *     ...
- * }
- * ```
- *
- * Roles can be granted and revoked dynamically via the {grantRole} and
- * {revokeRole} functions. Each role has an associated admin role, and only
- * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
- *
- * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
- * that only accounts with this role will be able to grant or revoke other
- * roles. More complex role relationships can be created by using
- * {_setRoleAdmin}.
- *
- * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
- * grant and revoke this role. Extra precautions should be taken to secure
- * accounts that have been granted it.
- */
-abstract contract AccessControl is Context, IAccessControl, ERC165 {
-    struct RoleData {
-        mapping(address => bool) members;
-        bytes32 adminRole;
-    }
-
-    mapping(bytes32 => RoleData) private _roles;
-
-    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
-
-    /**
-     * @dev Modifier that checks that an account has a specific role. Reverts
-     * with a standardized message including the required role.
-     *
-     * The format of the revert reason is given by the following regular expression:
-     *
-     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
-     *
-     * _Available since v4.1._
-     */
-    modifier onlyRole(bytes32 role) {
-        _checkRole(role);
-        _;
-    }
-
-    /**
-     * @dev See {IERC165-supportsInterface}.
-     */
-    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
-        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
-    }
-
-    /**
-     * @dev Returns `true` if `account` has been granted `role`.
-     */
-    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
-        return _roles[role].members[account];
-    }
-
-    /**
-     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
-     * Overriding this function changes the behavior of the {onlyRole} modifier.
-     *
-     * Format of the revert message is described in {_checkRole}.
-     *
-     * _Available since v4.6._
-     */
-    function _checkRole(bytes32 role) internal view virtual {
-        _checkRole(role, _msgSender());
-    }
-
-    /**
-     * @dev Revert with a standard message if `account` is missing `role`.
-     *
-     * The format of the revert reason is given by the following regular expression:
-     *
-     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
-     */
-    function _checkRole(bytes32 role, address account) internal view virtual {
-        if (!hasRole(role, account)) {
-            revert(
-                string(
-                    abi.encodePacked(
-                        "AccessControl: account ",
-                        Strings.toHexString(account),
-                        " is missing role ",
-                        Strings.toHexString(uint256(role), 32)
-                    )
-                )
-            );
-        }
-    }
-
-    /**
-     * @dev Returns the admin role that controls `role`. See {grantRole} and
-     * {revokeRole}.
-     *
-     * To change a role's admin, use {_setRoleAdmin}.
-     */
-    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
-        return _roles[role].adminRole;
-    }
-
-    /**
-     * @dev Grants `role` to `account`.
-     *
-     * If `account` had not been already granted `role`, emits a {RoleGranted}
-     * event.
-     *
-     * Requirements:
-     *
-     * - the caller must have ``role``'s admin role.
-     *
-     * May emit a {RoleGranted} event.
-     */
-    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
-        _grantRole(role, account);
-    }
-
-    /**
-     * @dev Revokes `role` from `account`.
-     *
-     * If `account` had been granted `role`, emits a {RoleRevoked} event.
-     *
-     * Requirements:
-     *
-     * - the caller must have ``role``'s admin role.
-     *
-     * May emit a {RoleRevoked} event.
-     */
-    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
-        _revokeRole(role, account);
-    }
-
-    /**
-     * @dev Revokes `role` from the calling account.
-     *
-     * Roles are often managed via {grantRole} and {revokeRole}: this function's
-     * purpose is to provide a mechanism for accounts to lose their privileges
-     * if they are compromised (such as when a trusted device is misplaced).
-     *
-     * If the calling account had been revoked `role`, emits a {RoleRevoked}
-     * event.
-     *
-     * Requirements:
-     *
-     * - the caller must be `account`.
-     *
-     * May emit a {RoleRevoked} event.
-     */
-    function renounceRole(bytes32 role, address account) public virtual override {
-        require(account == _msgSender(), "AccessControl: can only renounce roles for self");
-
-        _revokeRole(role, account);
-    }
-
-    /**
-     * @dev Grants `role` to `account`.
-     *
-     * If `account` had not been already granted `role`, emits a {RoleGranted}
-     * event. Note that unlike {grantRole}, this function doesn't perform any
-     * checks on the calling account.
-     *
-     * May emit a {RoleGranted} event.
-     *
-     * [WARNING]
-     * ====
-     * This function should only be called from the constructor when setting
-     * up the initial roles for the system.
-     *
-     * Using this function in any other way is effectively circumventing the admin
-     * system imposed by {AccessControl}.
-     * ====
-     *
-     * NOTE: This function is deprecated in favor of {_grantRole}.
-     */
-    function _setupRole(bytes32 role, address account) internal virtual {
-        _grantRole(role, account);
-    }
-
-    /**
-     * @dev Sets `adminRole` as ``role``'s admin role.
-     *
-     * Emits a {RoleAdminChanged} event.
-     */
-    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
-        bytes32 previousAdminRole = getRoleAdmin(role);
-        _roles[role].adminRole = adminRole;
-        emit RoleAdminChanged(role, previousAdminRole, adminRole);
-    }
-
-    /**
-     * @dev Grants `role` to `account`.
-     *
-     * Internal function without access restriction.
-     *
-     * May emit a {RoleGranted} event.
-     */
-    function _grantRole(bytes32 role, address account) internal virtual {
-        if (!hasRole(role, account)) {
-            _roles[role].members[account] = true;
-            emit RoleGranted(role, account, _msgSender());
-        }
-    }
-
-    /**
-     * @dev Revokes `role` from `account`.
-     *
-     * Internal function without access restriction.
-     *
-     * May emit a {RoleRevoked} event.
-     */
-    function _revokeRole(bytes32 role, address account) internal virtual {
-        if (hasRole(role, account)) {
-            _roles[role].members[account] = false;
-            emit RoleRevoked(role, account, _msgSender());
-        }
-    }
-}

contracts/access/AccessControlCrossChain.sol

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.6.0) (access/AccessControlCrossChain.sol)
-
-pragma solidity ^0.8.4;
-
-import "./AccessControl.sol";
-import "../crosschain/CrossChainEnabled.sol";
-
-/**
- * @dev An extension to {AccessControl} with support for cross-chain access management.
- * For each role, is extension implements an equivalent "aliased" role that is used for
- * restricting calls originating from other chains.
- *
- * For example, if a function `myFunction` is protected by `onlyRole(SOME_ROLE)`, and
- * if an address `x` has role `SOME_ROLE`, it would be able to call `myFunction` directly.
- * A wallet or contract at the same address on another chain would however not be able
- * to call this function. In order to do so, it would require to have the role
- * `_crossChainRoleAlias(SOME_ROLE)`.
- *
- * This aliasing is required to protect against multiple contracts living at the same
- * address on different chains but controlled by conflicting entities.
- *
- * _Available since v4.6._
- */
-abstract contract AccessControlCrossChain is AccessControl, CrossChainEnabled {
-    bytes32 public constant CROSSCHAIN_ALIAS = keccak256("CROSSCHAIN_ALIAS");
-
-    /**
-     * @dev See {AccessControl-_checkRole}.
-     */
-    function _checkRole(bytes32 role) internal view virtual override {
-        if (_isCrossChain()) {
-            _checkRole(_crossChainRoleAlias(role), _crossChainSender());
-        } else {
-            super._checkRole(role);
-        }
-    }
-
-    /**
-     * @dev Returns the aliased role corresponding to `role`.
-     */
-    function _crossChainRoleAlias(bytes32 role) internal pure virtual returns (bytes32) {
-        return role ^ CROSSCHAIN_ALIAS;
-    }
-}

contracts/access/AccessControlEnumerable.sol

@@ -1,64 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)
-
-pragma solidity ^0.8.0;
-
-import "./IAccessControlEnumerable.sol";
-import "./AccessControl.sol";
-import "../utils/structs/EnumerableSet.sol";
-
-/**
- * @dev Extension of {AccessControl} that allows enumerating the members of each role.
- */
-abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
-    using EnumerableSet for EnumerableSet.AddressSet;
-
-    mapping(bytes32 => EnumerableSet.AddressSet) private _roleMembers;
-
-    /**
-     * @dev See {IERC165-supportsInterface}.
-     */
-    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
-        return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
-    }
-
-    /**
-     * @dev Returns one of the accounts that have `role`. `index` must be a
-     * value between 0 and {getRoleMemberCount}, non-inclusive.
-     *
-     * Role bearers are not sorted in any particular way, and their ordering may
-     * change at any point.
-     *
-     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
-     * you perform all queries on the same block. See the following
-     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
-     * for more information.
-     */
-    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
-        return _roleMembers[role].at(index);
-    }
-
-    /**
-     * @dev Returns the number of accounts that have `role`. Can be used
-     * together with {getRoleMember} to enumerate all bearers of a role.
-     */
-    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
-        return _roleMembers[role].length();
-    }
-
-    /**
-     * @dev Overload {_grantRole} to track enumerable memberships
-     */
-    function _grantRole(bytes32 role, address account) internal virtual override {
-        super._grantRole(role, account);
-        _roleMembers[role].add(account);
-    }
-
-    /**
-     * @dev Overload {_revokeRole} to track enumerable memberships
-     */
-    function _revokeRole(bytes32 role, address account) internal virtual override {
-        super._revokeRole(role, account);
-        _roleMembers[role].remove(account);
-    }
-}

contracts/access/IAccessControl.sol

@@ -1,88 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
-
-pragma solidity ^0.8.0;
-
-/**
- * @dev External interface of AccessControl declared to support ERC165 detection.
- */
-interface IAccessControl {
-    /**
-     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
-     *
-     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
-     * {RoleAdminChanged} not being emitted signaling this.
-     *
-     * _Available since v3.1._
-     */
-    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
-
-    /**
-     * @dev Emitted when `account` is granted `role`.
-     *
-     * `sender` is the account that originated the contract call, an admin role
-     * bearer except when using {AccessControl-_setupRole}.
-     */
-    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
-
-    /**
-     * @dev Emitted when `account` is revoked `role`.
-     *
-     * `sender` is the account that originated the contract call:
-     *   - if using `revokeRole`, it is the admin role bearer
-     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
-     */
-    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
-
-    /**
-     * @dev Returns `true` if `account` has been granted `role`.
-     */
-    function hasRole(bytes32 role, address account) external view returns (bool);
-
-    /**
-     * @dev Returns the admin role that controls `role`. See {grantRole} and
-     * {revokeRole}.
-     *
-     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
-     */
-    function getRoleAdmin(bytes32 role) external view returns (bytes32);
-
-    /**
-     * @dev Grants `role` to `account`.
-     *
-     * If `account` had not been already granted `role`, emits a {RoleGranted}
-     * event.
-     *
-     * Requirements:
-     *
-     * - the caller must have ``role``'s admin role.
-     */
-    function grantRole(bytes32 role, address account) external;
-
-    /**
-     * @dev Revokes `role` from `account`.
-     *
-     * If `account` had been granted `role`, emits a {RoleRevoked} event.
-     *
-     * Requirements:
-     *
-     * - the caller must have ``role``'s admin role.
-     */
-    function revokeRole(bytes32 role, address account) external;
-
-    /**
-     * @dev Revokes `role` from the calling account.
-     *
-     * Roles are often managed via {grantRole} and {revokeRole}: this function's
-     * purpose is to provide a mechanism for accounts to lose their privileges
-     * if they are compromised (such as when a trusted device is misplaced).
-     *
-     * If the calling account had been granted `role`, emits a {RoleRevoked}
-     * event.
-     *
-     * Requirements:
-     *
-     * - the caller must be `account`.
-     */
-    function renounceRole(bytes32 role, address account) external;
-}

contracts/access/IAccessControlEnumerable.sol

@@ -1,31 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)
-
-pragma solidity ^0.8.0;
-
-import "./IAccessControl.sol";
-
-/**
- * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
- */
-interface IAccessControlEnumerable is IAccessControl {
-    /**
-     * @dev Returns one of the accounts that have `role`. `index` must be a
-     * value between 0 and {getRoleMemberCount}, non-inclusive.
-     *
-     * Role bearers are not sorted in any particular way, and their ordering may
-     * change at any point.
-     *
-     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
-     * you perform all queries on the same block. See the following
-     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
-     * for more information.
-     */
-    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
-
-    /**
-     * @dev Returns the number of accounts that have `role`. Can be used
-     * together with {getRoleMember} to enumerate all bearers of a role.
-     */
-    function getRoleMemberCount(bytes32 role) external view returns (uint256);
-}

contracts/access/Ownable2Step.sol

@@ -1,57 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.8.0) (access/Ownable2Step.sol)
-
-pragma solidity ^0.8.0;
-
-import "./Ownable.sol";
-
-/**
- * @dev Contract module which provides access control mechanism, where
- * there is an account (an owner) that can be granted exclusive access to
- * specific functions.
- *
- * By default, the owner account will be the one that deploys the contract. This
- * can later be changed with {transferOwnership} and {acceptOwnership}.
- *
- * This module is used through inheritance. It will make available all functions
- * from parent (Ownable).
- */
-abstract contract Ownable2Step is Ownable {
-    address private _pendingOwner;
-
-    event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
-
-    /**
-     * @dev Returns the address of the pending owner.
-     */
-    function pendingOwner() public view virtual returns (address) {
-        return _pendingOwner;
-    }
-
-    /**
-     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
-     * Can only be called by the current owner.
-     */
-    function transferOwnership(address newOwner) public virtual override onlyOwner {
-        _pendingOwner = newOwner;
-        emit OwnershipTransferStarted(owner(), newOwner);
-    }
-
-    /**
-     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
-     * Internal function without access restriction.
-     */
-    function _transferOwnership(address newOwner) internal virtual override {
-        delete _pendingOwner;
-        super._transferOwnership(newOwner);
-    }
-
-    /**
-     * @dev The new owner accepts the ownership transfer.
-     */
-    function acceptOwnership() external {
-        address sender = _msgSender();
-        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
-        _transferOwnership(sender);
-    }
-}

contracts/access/README.adoc

@@ -1,23 +0,0 @@
-= Access Control
-
-[.readme-notice]
-NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/access
-
-This directory provides ways to restrict who can access the functions of a contract or when they can do it.
-
-- {AccessControl} provides a general role based access control mechanism. Multiple hierarchical roles can be created and assigned each to multiple accounts.
-- {Ownable} is a simpler mechanism with a single owner "role" that can be assigned to a single account. This simpler mechanism can be useful for quick tests but projects with production concerns are likely to outgrow it.
-
-== Authorization
-
-{{Ownable}}
-
-{{IAccessControl}}
-
-{{AccessControl}}
-
-{{AccessControlCrossChain}}
-
-{{IAccessControlEnumerable}}
-
-{{AccessControlEnumerable}}

contracts/access/README.md

@@ -0,0 +1,9 @@
+---
+sections:
+  - title: Library
+    contracts:
+      - Roles
+  - subdirectory: roles
+---
+
+> This page is incomplete. We're working to improve it for the next release. Stay tuned!

contracts/access/Roles.sol

@@ -0,0 +1,36 @@
+pragma solidity ^0.5.0;
+
+/**
+ * @title Roles
+ * @dev Library for managing addresses assigned to a Role.
+ */
+library Roles {
+    struct Role {
+        mapping (address => bool) bearer;
+    }
+
+    /**
+     * @dev Give an account access to this role.
+     */
+    function add(Role storage role, address account) internal {
+        require(!has(role, account), "Roles: account already has role");
+        role.bearer[account] = true;
+    }
+
+    /**
+     * @dev Remove an account's access to this role.
+     */
+    function remove(Role storage role, address account) internal {
+        require(has(role, account), "Roles: account does not have role");
+        role.bearer[account] = false;
+    }
+
+    /**
+     * @dev Check if an account has this role.
+     * @return bool
+     */
+    function has(Role storage role, address account) internal view returns (bool) {
+        require(account != address(0), "Roles: account is the zero address");
+        return role.bearer[account];
+    }
+}

contracts/access/roles/CapperRole.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.5.0;
+
+import "../Roles.sol";
+
+contract CapperRole {
+    using Roles for Roles.Role;
+
+    event CapperAdded(address indexed account);
+    event CapperRemoved(address indexed account);
+
+    Roles.Role private _cappers;
+
+    constructor () internal {
+        _addCapper(msg.sender);
+    }
+
+    modifier onlyCapper() {
+        require(isCapper(msg.sender), "CapperRole: caller does not have the Capper role");
+        _;
+    }
+
+    function isCapper(address account) public view returns (bool) {
+        return _cappers.has(account);
+    }
+
+    function addCapper(address account) public onlyCapper {
+        _addCapper(account);
+    }
+
+    function renounceCapper() public {
+        _removeCapper(msg.sender);
+    }
+
+    function _addCapper(address account) internal {
+        _cappers.add(account);
+        emit CapperAdded(account);
+    }
+
+    function _removeCapper(address account) internal {
+        _cappers.remove(account);
+        emit CapperRemoved(account);
+    }
+}

contracts/access/roles/MinterRole.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.5.0;
+
+import "../Roles.sol";
+
+contract MinterRole {
+    using Roles for Roles.Role;
+
+    event MinterAdded(address indexed account);
+    event MinterRemoved(address indexed account);
+
+    Roles.Role private _minters;
+
+    constructor () internal {
+        _addMinter(msg.sender);
+    }
+
+    modifier onlyMinter() {
+        require(isMinter(msg.sender), "MinterRole: caller does not have the Minter role");
+        _;
+    }
+
+    function isMinter(address account) public view returns (bool) {
+        return _minters.has(account);
+    }
+
+    function addMinter(address account) public onlyMinter {
+        _addMinter(account);
+    }
+
+    function renounceMinter() public {
+        _removeMinter(msg.sender);
+    }
+
+    function _addMinter(address account) internal {
+        _minters.add(account);
+        emit MinterAdded(account);
+    }
+
+    function _removeMinter(address account) internal {
+        _minters.remove(account);
+        emit MinterRemoved(account);
+    }
+}

contracts/access/roles/PauserRole.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.5.0;
+
+import "../Roles.sol";
+
+contract PauserRole {
+    using Roles for Roles.Role;
+
+    event PauserAdded(address indexed account);
+    event PauserRemoved(address indexed account);
+
+    Roles.Role private _pausers;
+
+    constructor () internal {
+        _addPauser(msg.sender);
+    }
+
+    modifier onlyPauser() {
+        require(isPauser(msg.sender), "PauserRole: caller does not have the Pauser role");
+        _;
+    }
+
+    function isPauser(address account) public view returns (bool) {
+        return _pausers.has(account);
+    }
+
+    function addPauser(address account) public onlyPauser {
+        _addPauser(account);
+    }
+
+    function renouncePauser() public {
+        _removePauser(msg.sender);
+    }
+
+    function _addPauser(address account) internal {
+        _pausers.add(account);
+        emit PauserAdded(account);
+    }
+
+    function _removePauser(address account) internal {
+        _pausers.remove(account);
+        emit PauserRemoved(account);
+    }
+}

contracts/access/roles/SignerRole.sol

@@ -0,0 +1,43 @@
+pragma solidity ^0.5.0;
+
+import "../Roles.sol";
+
+contract SignerRole {
+    using Roles for Roles.Role;
+
+    event SignerAdded(address indexed account);
+    event SignerRemoved(address indexed account);
+
+    Roles.Role private _signers;
+
+    constructor () internal {
+        _addSigner(msg.sender);
+    }
+
+    modifier onlySigner() {
+        require(isSigner(msg.sender), "SignerRole: caller does not have the Signer role");
+        _;
+    }
+
+    function isSigner(address account) public view returns (bool) {
+        return _signers.has(account);
+    }
+
+    function addSigner(address account) public onlySigner {
+        _addSigner(account);
+    }
+
+    function renounceSigner() public {
+        _removeSigner(msg.sender);
+    }
+
+    function _addSigner(address account) internal {
+        _signers.add(account);
+        emit SignerAdded(account);
+    }
+
+    function _removeSigner(address account) internal {
+        _signers.remove(account);
+        emit SignerRemoved(account);
+    }
+}

contracts/access/roles/WhitelistAdminRole.sol

@@ -0,0 +1,47 @@
+pragma solidity ^0.5.0;
+
+import "../Roles.sol";
+
+/**
+ * @title WhitelistAdminRole
+ * @dev WhitelistAdmins are responsible for assigning and removing Whitelisted accounts.
+ */
+contract WhitelistAdminRole {
+    using Roles for Roles.Role;
+
+    event WhitelistAdminAdded(address indexed account);
+    event WhitelistAdminRemoved(address indexed account);
+
+    Roles.Role private _whitelistAdmins;
+
+    constructor () internal {
+        _addWhitelistAdmin(msg.sender);
+    }
+
+    modifier onlyWhitelistAdmin() {
+        require(isWhitelistAdmin(msg.sender), "WhitelistAdminRole: caller does not have the WhitelistAdmin role");
+        _;
+    }
+
+    function isWhitelistAdmin(address account) public view returns (bool) {
+        return _whitelistAdmins.has(account);
+    }
+
+    function addWhitelistAdmin(address account) public onlyWhitelistAdmin {
+        _addWhitelistAdmin(account);
+    }
+
+    function renounceWhitelistAdmin() public {
+        _removeWhitelistAdmin(msg.sender);
+    }
+
+    function _addWhitelistAdmin(address account) internal {
+        _whitelistAdmins.add(account);
+        emit WhitelistAdminAdded(account);
+    }
+
+    function _removeWhitelistAdmin(address account) internal {
+        _whitelistAdmins.remove(account);
+        emit WhitelistAdminRemoved(account);
+    }
+}

contracts/access/roles/WhitelistedRole.sol

@@ -0,0 +1,50 @@
+pragma solidity ^0.5.0;
+
+import "../Roles.sol";
+import "./WhitelistAdminRole.sol";
+
+/**
+ * @title WhitelistedRole
+ * @dev Whitelisted accounts have been approved by a WhitelistAdmin to perform certain actions (e.g. participate in a
+ * 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 {
+    using Roles for Roles.Role;
+
+    event WhitelistedAdded(address indexed account);
+    event WhitelistedRemoved(address indexed account);
+
+    Roles.Role private _whitelisteds;
+
+    modifier onlyWhitelisted() {
+        require(isWhitelisted(msg.sender), "WhitelistedRole: caller does not have the Whitelisted role");
+        _;
+    }
+
+    function isWhitelisted(address account) public view returns (bool) {
+        return _whitelisteds.has(account);
+    }
+
+    function addWhitelisted(address account) public onlyWhitelistAdmin {
+        _addWhitelisted(account);
+    }
+
+    function removeWhitelisted(address account) public onlyWhitelistAdmin {
+        _removeWhitelisted(account);
+    }
+
+    function renounceWhitelisted() public {
+        _removeWhitelisted(msg.sender);
+    }
+
+    function _addWhitelisted(address account) internal {
+        _whitelisteds.add(account);
+        emit WhitelistedAdded(account);
+    }
+
+    function _removeWhitelisted(address account) internal {
+        _whitelisteds.remove(account);
+        emit WhitelistedRemoved(account);
+    }
+}

contracts/crosschain/CrossChainEnabled.sol

@@ -1,54 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/CrossChainEnabled.sol)
-
-pragma solidity ^0.8.4;
-
-import "./errors.sol";
-
-/**
- * @dev Provides information for building cross-chain aware contracts. This
- * abstract contract provides accessors and modifiers to control the execution
- * flow when receiving cross-chain messages.
- *
- * Actual implementations of cross-chain aware contracts, which are based on
- * this abstraction, will  have to inherit from a bridge-specific
- * specialization. Such specializations are provided under
- * `crosschain/<chain>/CrossChainEnabled<chain>.sol`.
- *
- * _Available since v4.6._
- */
-abstract contract CrossChainEnabled {
-    /**
-     * @dev Throws if the current function call is not the result of a
-     * cross-chain execution.
-     */
-    modifier onlyCrossChain() {
-        if (!_isCrossChain()) revert NotCrossChainCall();
-        _;
-    }
-
-    /**
-     * @dev Throws if the current function call is not the result of a
-     * cross-chain execution initiated by `account`.
-     */
-    modifier onlyCrossChainSender(address expected) {
-        address actual = _crossChainSender();
-        if (expected != actual) revert InvalidCrossChainSender(actual, expected);
-        _;
-    }
-
-    /**
-     * @dev Returns whether the current function call is the result of a
-     * cross-chain message.
-     */
-    function _isCrossChain() internal view virtual returns (bool);
-
-    /**
-     * @dev Returns the address of the sender of the cross-chain message that
-     * triggered the current function call.
-     *
-     * IMPORTANT: Should revert with `NotCrossChainCall` if the current function
-     * call is not the result of a cross-chain message.
-     */
-    function _crossChainSender() internal view virtual returns (address);
-}

contracts/crosschain/README.adoc

@@ -1,34 +0,0 @@
-= Cross Chain Awareness
-
-[.readme-notice]
-NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/crosschain
-
-This directory provides building blocks to improve cross-chain awareness of smart contracts.
-
-- {CrossChainEnabled} is an abstraction that contains accessors and modifiers to control the execution flow when receiving cross-chain messages.
-
-== CrossChainEnabled specializations
-
-The following specializations of {CrossChainEnabled} provide implementations of the {CrossChainEnabled} abstraction for specific bridges. This can be used to complex cross-chain aware components such as {AccessControlCrossChain}.
-
-{{CrossChainEnabledAMB}}
-
-{{CrossChainEnabledArbitrumL1}}
-
-{{CrossChainEnabledArbitrumL2}}
-
-{{CrossChainEnabledOptimism}}
-
-{{CrossChainEnabledPolygonChild}}
-
-== Libraries for cross-chain
-
-In addition to the {CrossChainEnabled} abstraction, cross-chain awareness is also available through libraries. These libraries can be used to build complex designs such as contracts with the ability to interact with multiple bridges.
-
-{{LibAMB}}
-
-{{LibArbitrumL1}}
-
-{{LibArbitrumL2}}
-
-{{LibOptimism}}

contracts/crosschain/amb/CrossChainEnabledAMB.sol

@@ -1,49 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/amb/CrossChainEnabledAMB.sol)
-
-pragma solidity ^0.8.4;
-
-import "../CrossChainEnabled.sol";
-import "./LibAMB.sol";
-
-/**
- * @dev https://docs.tokenbridge.net/amb-bridge/about-amb-bridge[AMB]
- * specialization or the {CrossChainEnabled} abstraction.
- *
- * As of february 2020, AMB bridges are available between the following chains:
- *
- * - https://docs.tokenbridge.net/eth-xdai-amb-bridge/about-the-eth-xdai-amb[ETH ⇌ xDai]
- * - https://docs.tokenbridge.net/eth-qdai-bridge/about-the-eth-qdai-amb[ETH ⇌ qDai]
- * - https://docs.tokenbridge.net/eth-etc-amb-bridge/about-the-eth-etc-amb[ETH ⇌ ETC]
- * - https://docs.tokenbridge.net/eth-bsc-amb/about-the-eth-bsc-amb[ETH ⇌ BSC]
- * - https://docs.tokenbridge.net/eth-poa-amb-bridge/about-the-eth-poa-amb[ETH ⇌ POA]
- * - https://docs.tokenbridge.net/bsc-xdai-amb/about-the-bsc-xdai-amb[BSC ⇌ xDai]
- * - https://docs.tokenbridge.net/poa-xdai-amb/about-the-poa-xdai-amb[POA ⇌ xDai]
- * - https://docs.tokenbridge.net/rinkeby-xdai-amb-bridge/about-the-rinkeby-xdai-amb[Rinkeby ⇌ xDai]
- * - https://docs.tokenbridge.net/kovan-sokol-amb-bridge/about-the-kovan-sokol-amb[Kovan ⇌ Sokol]
- *
- * _Available since v4.6._
- */
-contract CrossChainEnabledAMB is CrossChainEnabled {
-    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    address private immutable _bridge;
-
-    /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(address bridge) {
-        _bridge = bridge;
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_isCrossChain}
-     */
-    function _isCrossChain() internal view virtual override returns (bool) {
-        return LibAMB.isCrossChain(_bridge);
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_crossChainSender}
-     */
-    function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {
-        return LibAMB.crossChainSender(_bridge);
-    }
-}

contracts/crosschain/amb/LibAMB.sol

@@ -1,35 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/amb/LibAMB.sol)
-
-pragma solidity ^0.8.4;
-
-import {IAMB as AMB_Bridge} from "../../vendor/amb/IAMB.sol";
-import "../errors.sol";
-
-/**
- * @dev Primitives for cross-chain aware contracts using the
- * https://docs.tokenbridge.net/amb-bridge/about-amb-bridge[AMB]
- * family of bridges.
- */
-library LibAMB {
-    /**
-     * @dev Returns whether the current function call is the result of a
-     * cross-chain message relayed by `bridge`.
-     */
-    function isCrossChain(address bridge) internal view returns (bool) {
-        return msg.sender == bridge;
-    }
-
-    /**
-     * @dev Returns the address of the sender that triggered the current
-     * cross-chain message through `bridge`.
-     *
-     * NOTE: {isCrossChain} should be checked before trying to recover the
-     * sender, as it will revert with `NotCrossChainCall` if the current
-     * function call is not the result of a cross-chain message.
-     */
-    function crossChainSender(address bridge) internal view returns (address) {
-        if (!isCrossChain(bridge)) revert NotCrossChainCall();
-        return AMB_Bridge(bridge).messageSender();
-    }
-}

contracts/crosschain/arbitrum/CrossChainEnabledArbitrumL1.sol

@@ -1,44 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/arbitrum/CrossChainEnabledArbitrumL1.sol)
-
-pragma solidity ^0.8.4;
-
-import "../CrossChainEnabled.sol";
-import "./LibArbitrumL1.sol";
-
-/**
- * @dev https://arbitrum.io/[Arbitrum] specialization or the
- * {CrossChainEnabled} abstraction the L1 side (mainnet).
- *
- * This version should only be deployed on L1 to process cross-chain messages
- * originating from L2. For the other side, use {CrossChainEnabledArbitrumL2}.
- *
- * The bridge contract is provided and maintained by the arbitrum team. You can
- * find the address of this contract on the rinkeby testnet in
- * https://developer.offchainlabs.com/docs/useful_addresses[Arbitrum's developer documentation].
- *
- * _Available since v4.6._
- */
-abstract contract CrossChainEnabledArbitrumL1 is CrossChainEnabled {
-    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    address private immutable _bridge;
-
-    /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(address bridge) {
-        _bridge = bridge;
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_isCrossChain}
-     */
-    function _isCrossChain() internal view virtual override returns (bool) {
-        return LibArbitrumL1.isCrossChain(_bridge);
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_crossChainSender}
-     */
-    function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {
-        return LibArbitrumL1.crossChainSender(_bridge);
-    }
-}

contracts/crosschain/arbitrum/CrossChainEnabledArbitrumL2.sol

@@ -1,40 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.8.0) (crosschain/arbitrum/CrossChainEnabledArbitrumL2.sol)
-
-pragma solidity ^0.8.4;
-
-import "../CrossChainEnabled.sol";
-import "./LibArbitrumL2.sol";
-
-/**
- * @dev https://arbitrum.io/[Arbitrum] specialization or the
- * {CrossChainEnabled} abstraction the L2 side (arbitrum).
- *
- * This version should only be deployed on L2 to process cross-chain messages
- * originating from L1. For the other side, use {CrossChainEnabledArbitrumL1}.
- *
- * Arbitrum L2 includes the `ArbSys` contract at a fixed address. Therefore,
- * this specialization of {CrossChainEnabled} does not include a constructor.
- *
- * _Available since v4.6._
- *
- * WARNING: There is currently a bug in Arbitrum that causes this contract to
- * fail to detect cross-chain calls when deployed behind a proxy. This will be
- * fixed when the network is upgraded to Arbitrum Nitro, currently scheduled for
- * August 31st 2022.
- */
-abstract contract CrossChainEnabledArbitrumL2 is CrossChainEnabled {
-    /**
-     * @dev see {CrossChainEnabled-_isCrossChain}
-     */
-    function _isCrossChain() internal view virtual override returns (bool) {
-        return LibArbitrumL2.isCrossChain(LibArbitrumL2.ARBSYS);
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_crossChainSender}
-     */
-    function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {
-        return LibArbitrumL2.crossChainSender(LibArbitrumL2.ARBSYS);
-    }
-}

contracts/crosschain/arbitrum/LibArbitrumL1.sol

@@ -1,42 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.8.0) (crosschain/arbitrum/LibArbitrumL1.sol)
-
-pragma solidity ^0.8.4;
-
-import {IBridge as ArbitrumL1_Bridge} from "../../vendor/arbitrum/IBridge.sol";
-import {IOutbox as ArbitrumL1_Outbox} from "../../vendor/arbitrum/IOutbox.sol";
-import "../errors.sol";
-
-/**
- * @dev Primitives for cross-chain aware contracts for
- * https://arbitrum.io/[Arbitrum].
- *
- * This version should only be used on L1 to process cross-chain messages
- * originating from L2. For the other side, use {LibArbitrumL2}.
- */
-library LibArbitrumL1 {
-    /**
-     * @dev Returns whether the current function call is the result of a
-     * cross-chain message relayed by the `bridge`.
-     */
-    function isCrossChain(address bridge) internal view returns (bool) {
-        return msg.sender == bridge;
-    }
-
-    /**
-     * @dev Returns the address of the sender that triggered the current
-     * cross-chain message through the `bridge`.
-     *
-     * NOTE: {isCrossChain} should be checked before trying to recover the
-     * sender, as it will revert with `NotCrossChainCall` if the current
-     * function call is not the result of a cross-chain message.
-     */
-    function crossChainSender(address bridge) internal view returns (address) {
-        if (!isCrossChain(bridge)) revert NotCrossChainCall();
-
-        address sender = ArbitrumL1_Outbox(ArbitrumL1_Bridge(bridge).activeOutbox()).l2ToL1Sender();
-        require(sender != address(0), "LibArbitrumL1: system messages without sender");
-
-        return sender;
-    }
-}

contracts/crosschain/arbitrum/LibArbitrumL2.sol

@@ -1,45 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.8.0) (crosschain/arbitrum/LibArbitrumL2.sol)
-
-pragma solidity ^0.8.4;
-
-import {IArbSys as ArbitrumL2_Bridge} from "../../vendor/arbitrum/IArbSys.sol";
-import "../errors.sol";
-
-/**
- * @dev Primitives for cross-chain aware contracts for
- * https://arbitrum.io/[Arbitrum].
- *
- * This version should only be used on L2 to process cross-chain messages
- * originating from L1. For the other side, use {LibArbitrumL1}.
- *
- * WARNING: There is currently a bug in Arbitrum that causes this contract to
- * fail to detect cross-chain calls when deployed behind a proxy. This will be
- * fixed when the network is upgraded to Arbitrum Nitro, currently scheduled for
- * August 31st 2022.
- */
-library LibArbitrumL2 {
-    /**
-     * @dev Returns whether the current function call is the result of a
-     * cross-chain message relayed by `arbsys`.
-     */
-    address public constant ARBSYS = 0x0000000000000000000000000000000000000064;
-
-    function isCrossChain(address arbsys) internal view returns (bool) {
-        return ArbitrumL2_Bridge(arbsys).wasMyCallersAddressAliased();
-    }
-
-    /**
-     * @dev Returns the address of the sender that triggered the current
-     * cross-chain message through `arbsys`.
-     *
-     * NOTE: {isCrossChain} should be checked before trying to recover the
-     * sender, as it will revert with `NotCrossChainCall` if the current
-     * function call is not the result of a cross-chain message.
-     */
-    function crossChainSender(address arbsys) internal view returns (address) {
-        if (!isCrossChain(arbsys)) revert NotCrossChainCall();
-
-        return ArbitrumL2_Bridge(arbsys).myCallersAddressWithoutAliasing();
-    }
-}

contracts/crosschain/errors.sol

@@ -1,7 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.6.0) (crosschain/errors.sol)
-
-pragma solidity ^0.8.4;
-
-error NotCrossChainCall();
-error InvalidCrossChainSender(address actual, address expected);

contracts/crosschain/optimism/CrossChainEnabledOptimism.sol

@@ -1,41 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/optimism/CrossChainEnabledOptimism.sol)
-
-pragma solidity ^0.8.4;
-
-import "../CrossChainEnabled.sol";
-import "./LibOptimism.sol";
-
-/**
- * @dev https://www.optimism.io/[Optimism] specialization or the
- * {CrossChainEnabled} abstraction.
- *
- * The messenger (`CrossDomainMessenger`) contract is provided and maintained by
- * the optimism team. You can find the address of this contract on mainnet and
- * kovan in the https://github.com/ethereum-optimism/optimism/tree/develop/packages/contracts/deployments[deployments section of Optimism monorepo].
- *
- * _Available since v4.6._
- */
-abstract contract CrossChainEnabledOptimism is CrossChainEnabled {
-    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    address private immutable _messenger;
-
-    /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(address messenger) {
-        _messenger = messenger;
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_isCrossChain}
-     */
-    function _isCrossChain() internal view virtual override returns (bool) {
-        return LibOptimism.isCrossChain(_messenger);
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_crossChainSender}
-     */
-    function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {
-        return LibOptimism.crossChainSender(_messenger);
-    }
-}

contracts/crosschain/optimism/LibOptimism.sol

@@ -1,36 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/optimism/LibOptimism.sol)
-
-pragma solidity ^0.8.4;
-
-import {ICrossDomainMessenger as Optimism_Bridge} from "../../vendor/optimism/ICrossDomainMessenger.sol";
-import "../errors.sol";
-
-/**
- * @dev Primitives for cross-chain aware contracts for https://www.optimism.io/[Optimism].
- * See the https://community.optimism.io/docs/developers/bridge/messaging/#accessing-msg-sender[documentation]
- * for the functionality used here.
- */
-library LibOptimism {
-    /**
-     * @dev Returns whether the current function call is the result of a
-     * cross-chain message relayed by `messenger`.
-     */
-    function isCrossChain(address messenger) internal view returns (bool) {
-        return msg.sender == messenger;
-    }
-
-    /**
-     * @dev Returns the address of the sender that triggered the current
-     * cross-chain message through `messenger`.
-     *
-     * NOTE: {isCrossChain} should be checked before trying to recover the
-     * sender, as it will revert with `NotCrossChainCall` if the current
-     * function call is not the result of a cross-chain message.
-     */
-    function crossChainSender(address messenger) internal view returns (address) {
-        if (!isCrossChain(messenger)) revert NotCrossChainCall();
-
-        return Optimism_Bridge(messenger).xDomainMessageSender();
-    }
-}

contracts/crosschain/polygon/CrossChainEnabledPolygonChild.sol

@@ -1,72 +0,0 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts (last updated v4.7.0) (crosschain/polygon/CrossChainEnabledPolygonChild.sol)
-
-pragma solidity ^0.8.4;
-
-import "../CrossChainEnabled.sol";
-import "../../security/ReentrancyGuard.sol";
-import "../../utils/Address.sol";
-import "../../vendor/polygon/IFxMessageProcessor.sol";
-
-address constant DEFAULT_SENDER = 0x000000000000000000000000000000000000dEaD;
-
-/**
- * @dev https://polygon.technology/[Polygon] specialization or the
- * {CrossChainEnabled} abstraction the child side (polygon/mumbai).
- *
- * This version should only be deployed on child chain to process cross-chain
- * messages originating from the parent chain.
- *
- * The fxChild contract is provided and maintained by the polygon team. You can
- * find the address of this contract polygon and mumbai in
- * https://docs.polygon.technology/docs/develop/l1-l2-communication/fx-portal/#contract-addresses[Polygon's Fx-Portal documentation].
- *
- * _Available since v4.6._
- */
-abstract contract CrossChainEnabledPolygonChild is IFxMessageProcessor, CrossChainEnabled, ReentrancyGuard {
-    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable
-    address private immutable _fxChild;
-    address private _sender = DEFAULT_SENDER;
-
-    /// @custom:oz-upgrades-unsafe-allow constructor
-    constructor(address fxChild) {
-        _fxChild = fxChild;
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_isCrossChain}
-     */
-    function _isCrossChain() internal view virtual override returns (bool) {
-        return msg.sender == _fxChild;
-    }
-
-    /**
-     * @dev see {CrossChainEnabled-_crossChainSender}
-     */
-    function _crossChainSender() internal view virtual override onlyCrossChain returns (address) {
-        return _sender;
-    }
-
-    /**
-     * @dev External entry point to receive and relay messages originating
-     * from the fxChild.
-     *
-     * Non-reentrancy is crucial to avoid a cross-chain call being able
-     * to impersonate anyone by just looping through this with user-defined
-     * arguments.
-     *
-     * Note: if _fxChild calls any other function that does a delegate-call,
-     * then security could be compromised.
-     */
-    function processMessageFromRoot(
-        uint256, /* stateId */
-        address rootMessageSender,
-        bytes calldata data
-    ) external override nonReentrant {
-        if (!_isCrossChain()) revert NotCrossChainCall();
-
-        _sender = rootMessageSender;
-        Address.functionDelegateCall(address(this), data, "cross-chain execution failed");
-        _sender = DEFAULT_SENDER;
-    }
-}

contracts/crowdsale/Crowdsale.sol

@@ -0,0 +1,198 @@
+pragma solidity ^0.5.0;
+
+import "../token/ERC20/IERC20.sol";
+import "../math/SafeMath.sol";
+import "../token/ERC20/SafeERC20.sol";
+import "../utils/ReentrancyGuard.sol";
+
+/**
+ * @title Crowdsale
+ * @dev Crowdsale is a base contract for managing a token crowdsale,
+ * allowing investors to purchase tokens with ether. This contract implements
+ * such functionality in its most fundamental form and can be extended to provide additional
+ * functionality and/or custom behavior.
+ * The external interface represents the basic interface for purchasing tokens, and conforms
+ * the base architecture for crowdsales. It is *not* intended to be modified / overridden.
+ * The internal interface conforms the extensible and modifiable surface of crowdsales. Override
+ * the methods to add functionality. Consider using 'super' where appropriate to concatenate
+ * behavior.
+ */
+contract Crowdsale is ReentrancyGuard {
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
+
+    // The token being sold
+    IERC20 private _token;
+
+    // Address where funds are collected
+    address payable private _wallet;
+
+    // How many token units a buyer gets per wei.
+    // The rate is the conversion between wei and the smallest and indivisible token unit.
+    // So, if you are using a rate of 1 with a ERC20Detailed token with 3 decimals called TOK
+    // 1 wei will give you 1 unit, or 0.001 TOK.
+    uint256 private _rate;
+
+    // Amount of wei raised
+    uint256 private _weiRaised;
+
+    /**
+     * Event for token purchase logging
+     * @param purchaser who paid for the tokens
+     * @param beneficiary who got the tokens
+     * @param value weis paid for purchase
+     * @param amount amount of tokens purchased
+     */
+    event TokensPurchased(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
+
+    /**
+     * @param rate Number of token units a buyer gets per wei
+     * @dev The rate is the conversion between wei and the smallest and indivisible
+     * token unit. So, if you are using a rate of 1 with a ERC20Detailed token
+     * with 3 decimals called TOK, 1 wei will give you 1 unit, or 0.001 TOK.
+     * @param wallet Address where collected funds will be forwarded to
+     * @param token Address of the token being sold
+     */
+    constructor (uint256 rate, address payable wallet, IERC20 token) public {
+        require(rate > 0, "Crowdsale: rate is 0");
+        require(wallet != address(0), "Crowdsale: wallet is the zero address");
+        require(address(token) != address(0), "Crowdsale: token is the zero address");
+
+        _rate = rate;
+        _wallet = wallet;
+        _token = token;
+    }
+
+    /**
+     * @dev fallback function ***DO NOT OVERRIDE***
+     * Note that other contracts will transfer funds with a base gas stipend
+     * of 2300, which is not enough to call buyTokens. Consider calling
+     * buyTokens directly when purchasing tokens from a contract.
+     */
+    function () external payable {
+        buyTokens(msg.sender);
+    }
+
+    /**
+     * @return the token being sold.
+     */
+    function token() public view returns (IERC20) {
+        return _token;
+    }
+
+    /**
+     * @return the address where funds are collected.
+     */
+    function wallet() public view returns (address payable) {
+        return _wallet;
+    }
+
+    /**
+     * @return the number of token units a buyer gets per wei.
+     */
+    function rate() public view returns (uint256) {
+        return _rate;
+    }
+
+    /**
+     * @return the amount of wei raised.
+     */
+    function weiRaised() public view returns (uint256) {
+        return _weiRaised;
+    }
+
+    /**
+     * @dev low level token purchase ***DO NOT OVERRIDE***
+     * This function has a non-reentrancy guard, so it shouldn't be called by
+     * another `nonReentrant` function.
+     * @param beneficiary Recipient of the token purchase
+     */
+    function buyTokens(address beneficiary) public nonReentrant payable {
+        uint256 weiAmount = msg.value;
+        _preValidatePurchase(beneficiary, weiAmount);
+
+        // calculate token amount to be created
+        uint256 tokens = _getTokenAmount(weiAmount);
+
+        // update state
+        _weiRaised = _weiRaised.add(weiAmount);
+
+        _processPurchase(beneficiary, tokens);
+        emit TokensPurchased(msg.sender, beneficiary, weiAmount, tokens);
+
+        _updatePurchasingState(beneficiary, weiAmount);
+
+        _forwardFunds();
+        _postValidatePurchase(beneficiary, weiAmount);
+    }
+
+    /**
+     * @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.
+     * Example from CappedCrowdsale.sol's _preValidatePurchase method:
+     *     super._preValidatePurchase(beneficiary, weiAmount);
+     *     require(weiRaised().add(weiAmount) <= cap);
+     * @param beneficiary Address performing the token purchase
+     * @param weiAmount Value in wei involved in the purchase
+     */
+    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
+        require(beneficiary != address(0), "Crowdsale: beneficiary is the zero address");
+        require(weiAmount != 0, "Crowdsale: weiAmount is 0");
+    }
+
+    /**
+     * @dev Validation of an executed purchase. Observe state and use revert statements to undo rollback when valid
+     * conditions are not met.
+     * @param beneficiary Address performing the token purchase
+     * @param weiAmount Value in wei involved in the purchase
+     */
+    function _postValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    /**
+     * @dev Source of tokens. Override this method to modify the way in which the crowdsale ultimately gets and sends
+     * its tokens.
+     * @param beneficiary Address performing the token purchase
+     * @param tokenAmount Number of tokens to be emitted
+     */
+    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
+        _token.safeTransfer(beneficiary, tokenAmount);
+    }
+
+    /**
+     * @dev Executed when a purchase has been validated and is ready to be executed. Doesn't necessarily emit/send
+     * tokens.
+     * @param beneficiary Address receiving the tokens
+     * @param tokenAmount Number of tokens to be purchased
+     */
+    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
+        _deliverTokens(beneficiary, tokenAmount);
+    }
+
+    /**
+     * @dev Override for extensions that require an internal state to check for validity (current user contributions,
+     * etc.)
+     * @param beneficiary Address receiving the tokens
+     * @param weiAmount Value in wei involved in the purchase
+     */
+    function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+
+    /**
+     * @dev Override to extend the way in which ether is converted to tokens.
+     * @param weiAmount Value in wei to be converted into tokens
+     * @return Number of tokens that can be purchased with the specified _weiAmount
+     */
+    function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
+        return weiAmount.mul(_rate);
+    }
+
+    /**
+     * @dev Determines how ETH is stored/forwarded on purchases.
+     */
+    function _forwardFunds() internal {
+        _wallet.transfer(msg.value);
+    }
+}

contracts/crowdsale/README.md

@@ -0,0 +1,13 @@
+---
+title: Crowdsales
+sections:
+  - title: Core
+    contracts:
+      - Crowdsale
+  - subdirectory: emission
+  - subdirectory: price
+  - subdirectory: validation
+  - subdirectory: distribution
+---
+
+> This page is incomplete. We're working to improve it for the next release. Stay tuned!

contracts/crowdsale/distribution/FinalizableCrowdsale.sol

@@ -0,0 +1,51 @@
+pragma solidity ^0.5.0;
+
+import "../../math/SafeMath.sol";
+import "../validation/TimedCrowdsale.sol";
+
+/**
+ * @title FinalizableCrowdsale
+ * @dev Extension of TimedCrowdsale with a one-off finalization action, where one
+ * can do extra work after finishing.
+ */
+contract FinalizableCrowdsale is TimedCrowdsale {
+    using SafeMath for uint256;
+
+    bool private _finalized;
+
+    event CrowdsaleFinalized();
+
+    constructor () internal {
+        _finalized = false;
+    }
+
+    /**
+     * @return true if the crowdsale is finalized, false otherwise.
+     */
+    function finalized() public view returns (bool) {
+        return _finalized;
+    }
+
+    /**
+     * @dev Must be called after crowdsale ends, to do some extra finalization
+     * work. Calls the contract's finalization function.
+     */
+    function finalize() public {
+        require(!_finalized, "FinalizableCrowdsale: already finalized");
+        require(hasClosed(), "FinalizableCrowdsale: not closed");
+
+        _finalized = true;
+
+        _finalization();
+        emit CrowdsaleFinalized();
+    }
+
+    /**
+     * @dev Can be overridden to add finalization logic. The overriding function
+     * should call super._finalization() to ensure the chain of finalization is
+     * executed entirely.
+     */
+    function _finalization() internal {
+        // solhint-disable-previous-line no-empty-blocks
+    }
+}

contracts/crowdsale/distribution/PostDeliveryCrowdsale.sol

@@ -0,0 +1,65 @@
+pragma solidity ^0.5.0;
+
+import "../validation/TimedCrowdsale.sol";
+import "../../math/SafeMath.sol";
+import "../../ownership/Secondary.sol";
+import "../../token/ERC20/IERC20.sol";
+
+/**
+ * @title PostDeliveryCrowdsale
+ * @dev Crowdsale that locks tokens from withdrawal until it ends.
+ */
+contract PostDeliveryCrowdsale is TimedCrowdsale {
+    using SafeMath for uint256;
+
+    mapping(address => uint256) private _balances;
+    __unstable__TokenVault private _vault;
+
+    constructor() public {
+        _vault = new __unstable__TokenVault();
+    }
+
+    /**
+     * @dev Withdraw tokens only after crowdsale ends.
+     * @param beneficiary Whose tokens will be withdrawn.
+     */
+    function withdrawTokens(address beneficiary) public {
+        require(hasClosed(), "PostDeliveryCrowdsale: not closed");
+        uint256 amount = _balances[beneficiary];
+        require(amount > 0, "PostDeliveryCrowdsale: beneficiary is not due any tokens");
+
+        _balances[beneficiary] = 0;
+        _vault.transfer(token(), beneficiary, amount);
+    }
+
+    /**
+     * @return the balance of an account.
+     */
+    function balanceOf(address account) public view returns (uint256) {
+        return _balances[account];
+    }
+
+    /**
+     * @dev Overrides parent by storing due balances, and delivering tokens to the vault instead of the end user. This
+     * ensures that the tokens will be available by the time they are withdrawn (which may not be the case if
+     * `_deliverTokens` was called later).
+     * @param beneficiary Token purchaser
+     * @param tokenAmount Amount of tokens purchased
+     */
+    function _processPurchase(address beneficiary, uint256 tokenAmount) internal {
+        _balances[beneficiary] = _balances[beneficiary].add(tokenAmount);
+        _deliverTokens(address(_vault), tokenAmount);
+    }
+}
+
+/**
+ * @title __unstable__TokenVault
+ * @dev Similar to an Escrow for tokens, this contract allows its primary account to spend its tokens as it sees fit.
+ * This contract is an internal helper for PostDeliveryCrowdsale, and should not be used outside of this context.
+ */
+// solhint-disable-next-line contract-name-camelcase
+contract __unstable__TokenVault is Secondary {
+    function transfer(IERC20 token, address to, uint256 amount) public onlyPrimary {
+        token.transfer(to, amount);
+    }
+}

contracts/crowdsale/distribution/RefundableCrowdsale.sol

@@ -0,0 +1,82 @@
+pragma solidity ^0.5.0;
+
+import "../../math/SafeMath.sol";
+import "./FinalizableCrowdsale.sol";
+import "../../payment/escrow/RefundEscrow.sol";
+
+/**
+ * @title RefundableCrowdsale
+ * @dev Extension of `FinalizableCrowdsale` contract that adds a funding goal, and the possibility of users
+ * getting a refund if goal is not met.
+ *
+ * Deprecated, use `RefundablePostDeliveryCrowdsale` instead. Note that if you allow tokens to be traded before the goal
+ * is met, then an attack is possible in which the attacker purchases tokens from the crowdsale and when they sees that
+ * the goal is unlikely to be met, they sell their tokens (possibly at a discount). The attacker will be refunded when
+ * the crowdsale is finalized, and the users that purchased from them will be left with worthless tokens.
+ */
+contract RefundableCrowdsale is FinalizableCrowdsale {
+    using SafeMath for uint256;
+
+    // minimum amount of funds to be raised in weis
+    uint256 private _goal;
+
+    // refund escrow used to hold funds while crowdsale is running
+    RefundEscrow private _escrow;
+
+    /**
+     * @dev Constructor, creates RefundEscrow.
+     * @param goal Funding goal
+     */
+    constructor (uint256 goal) public {
+        require(goal > 0, "RefundableCrowdsale: goal is 0");
+        _escrow = new RefundEscrow(wallet());
+        _goal = goal;
+    }
+
+    /**
+     * @return minimum amount of funds to be raised in wei.
+     */
+    function goal() public view returns (uint256) {
+        return _goal;
+    }
+
+    /**
+     * @dev Investors can claim refunds here if crowdsale is unsuccessful.
+     * @param refundee Whose refund will be claimed.
+     */
+    function claimRefund(address payable refundee) public {
+        require(finalized(), "RefundableCrowdsale: not finalized");
+        require(!goalReached(), "RefundableCrowdsale: goal reached");
+
+        _escrow.withdraw(refundee);
+    }
+
+    /**
+     * @dev Checks whether funding goal was reached.
+     * @return Whether funding goal was reached
+     */
+    function goalReached() public view returns (bool) {
+        return weiRaised() >= _goal;
+    }
+
+    /**
+     * @dev Escrow finalization task, called when finalize() is called.
+     */
+    function _finalization() internal {
+        if (goalReached()) {
+            _escrow.close();
+            _escrow.beneficiaryWithdraw();
+        } else {
+            _escrow.enableRefunds();
+        }
+
+        super._finalization();
+    }
+
+    /**
+     * @dev Overrides Crowdsale fund forwarding, sending funds to escrow.
+     */
+    function _forwardFunds() internal {
+        _escrow.deposit.value(msg.value)(msg.sender);
+    }
+}

contracts/crowdsale/distribution/RefundablePostDeliveryCrowdsale.sol

@@ -0,0 +1,20 @@
+pragma solidity ^0.5.0;
+
+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 {
+    function withdrawTokens(address beneficiary) public {
+        require(finalized(), "RefundablePostDeliveryCrowdsale: not finalized");
+        require(goalReached(), "RefundablePostDeliveryCrowdsale: goal not reached");
+
+        super.withdrawTokens(beneficiary);
+    }
+}

contracts/crowdsale/emission/AllowanceCrowdsale.sol

@@ -0,0 +1,51 @@
+pragma solidity ^0.5.0;
+
+import "../Crowdsale.sol";
+import "../../token/ERC20/IERC20.sol";
+import "../../token/ERC20/SafeERC20.sol";
+import "../../math/SafeMath.sol";
+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 {
+    using SafeMath for uint256;
+    using SafeERC20 for IERC20;
+
+    address private _tokenWallet;
+
+    /**
+     * @dev Constructor, takes token wallet address.
+     * @param tokenWallet Address holding the tokens, which has approved allowance to the crowdsale.
+     */
+    constructor (address tokenWallet) public {
+        require(tokenWallet != address(0), "AllowanceCrowdsale: token wallet is the zero address");
+        _tokenWallet = tokenWallet;
+    }
+
+    /**
+     * @return the address of the wallet that will hold the tokens.
+     */
+    function tokenWallet() public view returns (address) {
+        return _tokenWallet;
+    }
+
+    /**
+     * @dev Checks the amount of tokens left in the allowance.
+     * @return Amount of tokens left in the allowance
+     */
+    function remainingTokens() public view returns (uint256) {
+        return Math.min(token().balanceOf(_tokenWallet), token().allowance(_tokenWallet, address(this)));
+    }
+
+    /**
+     * @dev Overrides parent behavior by transferring tokens from wallet.
+     * @param beneficiary Token purchaser
+     * @param tokenAmount Amount of tokens purchased
+     */
+    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
+        token().safeTransferFrom(_tokenWallet, beneficiary, tokenAmount);
+    }
+}

contracts/crowdsale/emission/MintedCrowdsale.sol

@@ -0,0 +1,24 @@
+pragma solidity ^0.5.0;
+
+import "../Crowdsale.sol";
+import "../../token/ERC20/ERC20Mintable.sol";
+
+/**
+ * @title MintedCrowdsale
+ * @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 {
+    /**
+     * @dev Overrides delivery by minting tokens upon purchase.
+     * @param beneficiary Token purchaser
+     * @param tokenAmount Number of tokens to be minted
+     */
+    function _deliverTokens(address beneficiary, uint256 tokenAmount) internal {
+        // Potentially dangerous assumption about the type of the token.
+        require(
+            ERC20Mintable(address(token())).mint(beneficiary, tokenAmount),
+                "MintedCrowdsale: minting failed"
+        );
+    }
+}

contracts/crowdsale/price/IncreasingPriceCrowdsale.sol

@@ -0,0 +1,79 @@
+pragma solidity ^0.5.0;
+
+import "../validation/TimedCrowdsale.sol";
+import "../../math/SafeMath.sol";
+
+/**
+ * @title IncreasingPriceCrowdsale
+ * @dev Extension of Crowdsale contract that increases the price of tokens linearly in time.
+ * 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 {
+    using SafeMath for uint256;
+
+    uint256 private _initialRate;
+    uint256 private _finalRate;
+
+    /**
+     * @dev Constructor, takes initial and final rates of tokens received per wei contributed.
+     * @param initialRate Number of tokens a buyer gets per wei at the start of the crowdsale
+     * @param finalRate Number of tokens a buyer gets per wei at the end of the crowdsale
+     */
+    constructor (uint256 initialRate, uint256 finalRate) public {
+        require(finalRate > 0, "IncreasingPriceCrowdsale: final rate is 0");
+        // solhint-disable-next-line max-line-length
+        require(initialRate > finalRate, "IncreasingPriceCrowdsale: initial rate is not greater than final rate");
+        _initialRate = initialRate;
+        _finalRate = finalRate;
+    }
+
+    /**
+     * The base rate function is overridden to revert, since this crowdsale doesn't use it, and
+     * all calls to it are a mistake.
+     */
+    function rate() public view returns (uint256) {
+        revert("IncreasingPriceCrowdsale: rate() called");
+    }
+
+    /**
+     * @return the initial rate of the crowdsale.
+     */
+    function initialRate() public view returns (uint256) {
+        return _initialRate;
+    }
+
+    /**
+     * @return the final rate of the crowdsale.
+     */
+    function finalRate() public view returns (uint256) {
+        return _finalRate;
+    }
+
+    /**
+     * @dev Returns the rate of tokens per wei at the present time.
+     * Note that, as price _increases_ with time, the rate _decreases_.
+     * @return The number of tokens a buyer gets per wei at a given time
+     */
+    function getCurrentRate() public view returns (uint256) {
+        if (!isOpen()) {
+            return 0;
+        }
+
+        // solhint-disable-next-line not-rely-on-time
+        uint256 elapsedTime = block.timestamp.sub(openingTime());
+        uint256 timeRange = closingTime().sub(openingTime());
+        uint256 rateRange = _initialRate.sub(_finalRate);
+        return _initialRate.sub(elapsedTime.mul(rateRange).div(timeRange));
+    }
+
+    /**
+     * @dev Overrides parent method taking into account variable rate.
+     * @param weiAmount The value in wei to be converted into tokens
+     * @return The number of tokens _weiAmount wei will buy at present time
+     */
+    function _getTokenAmount(uint256 weiAmount) internal view returns (uint256) {
+        uint256 currentRate = getCurrentRate();
+        return currentRate.mul(weiAmount);
+    }
+}

contracts/crowdsale/validation/CappedCrowdsale.sol

@@ -0,0 +1,48 @@
+pragma solidity ^0.5.0;
+
+import "../../math/SafeMath.sol";
+import "../Crowdsale.sol";
+
+/**
+ * @title CappedCrowdsale
+ * @dev Crowdsale with a limit for total contributions.
+ */
+contract CappedCrowdsale is Crowdsale {
+    using SafeMath for uint256;
+
+    uint256 private _cap;
+
+    /**
+     * @dev Constructor, takes maximum amount of wei accepted in the crowdsale.
+     * @param cap Max amount of wei to be contributed
+     */
+    constructor (uint256 cap) public {
+        require(cap > 0, "CappedCrowdsale: cap is 0");
+        _cap = cap;
+    }
+
+    /**
+     * @return the cap of the crowdsale.
+     */
+    function cap() public view returns (uint256) {
+        return _cap;
+    }
+
+    /**
+     * @dev Checks whether the cap has been reached.
+     * @return Whether the cap was reached
+     */
+    function capReached() public view returns (bool) {
+        return weiRaised() >= _cap;
+    }
+
+    /**
+     * @dev Extend parent behavior requiring purchase to respect the funding cap.
+     * @param beneficiary Token purchaser
+     * @param weiAmount Amount of wei contributed
+     */
+    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
+        super._preValidatePurchase(beneficiary, weiAmount);
+        require(weiRaised().add(weiAmount) <= _cap, "CappedCrowdsale: cap exceeded");
+    }
+}

contracts/crowdsale/validation/IndividuallyCappedCrowdsale.sol

@@ -0,0 +1,64 @@
+pragma solidity ^0.5.0;
+
+import "../../math/SafeMath.sol";
+import "../Crowdsale.sol";
+import "../../access/roles/CapperRole.sol";
+
+/**
+ * @title IndividuallyCappedCrowdsale
+ * @dev Crowdsale with per-beneficiary caps.
+ */
+contract IndividuallyCappedCrowdsale is Crowdsale, CapperRole {
+    using SafeMath for uint256;
+
+    mapping(address => uint256) private _contributions;
+    mapping(address => uint256) private _caps;
+
+    /**
+     * @dev Sets a specific beneficiary's maximum contribution.
+     * @param beneficiary Address to be capped
+     * @param cap Wei limit for individual contribution
+     */
+    function setCap(address beneficiary, uint256 cap) external onlyCapper {
+        _caps[beneficiary] = cap;
+    }
+
+    /**
+     * @dev Returns the cap of a specific beneficiary.
+     * @param beneficiary Address whose cap is to be checked
+     * @return Current cap for individual beneficiary
+     */
+    function getCap(address beneficiary) public view returns (uint256) {
+        return _caps[beneficiary];
+    }
+
+    /**
+     * @dev Returns the amount contributed so far by a specific beneficiary.
+     * @param beneficiary Address of contributor
+     * @return Beneficiary contribution so far
+     */
+    function getContribution(address beneficiary) public view returns (uint256) {
+        return _contributions[beneficiary];
+    }
+
+    /**
+     * @dev Extend parent behavior requiring purchase to respect the beneficiary's funding cap.
+     * @param beneficiary Token purchaser
+     * @param weiAmount Amount of wei contributed
+     */
+    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal view {
+        super._preValidatePurchase(beneficiary, weiAmount);
+        // solhint-disable-next-line max-line-length
+        require(_contributions[beneficiary].add(weiAmount) <= _caps[beneficiary], "IndividuallyCappedCrowdsale: beneficiary's cap exceeded");
+    }
+
+    /**
+     * @dev Extend parent behavior to update beneficiary contributions.
+     * @param beneficiary Token purchaser
+     * @param weiAmount Amount of wei contributed
+     */
+    function _updatePurchasingState(address beneficiary, uint256 weiAmount) internal {
+        super._updatePurchasingState(beneficiary, weiAmount);
+        _contributions[beneficiary] = _contributions[beneficiary].add(weiAmount);
+    }
+}

contracts/crowdsale/validation/PausableCrowdsale.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.5.0;
+
+import "../Crowdsale.sol";
+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 {
+    /**
+     * @dev Validation of an incoming purchase. Use require statements to revert state when conditions are not met.
+     * Use super to concatenate validations.
+     * Adds the validation that the crowdsale must not be paused.
+     * @param _beneficiary Address performing the token purchase
+     * @param _weiAmount Value in wei involved in the purchase
+     */
+    function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view whenNotPaused {
+        return super._preValidatePurchase(_beneficiary, _weiAmount);
+    }
+}

contracts/crowdsale/validation/TimedCrowdsale.sol

@@ -0,0 +1,98 @@
+pragma solidity ^0.5.0;
+
+import "../../math/SafeMath.sol";
+import "../Crowdsale.sol";
+
+/**
+ * @title TimedCrowdsale
+ * @dev Crowdsale accepting contributions only within a time frame.
+ */
+contract TimedCrowdsale is Crowdsale {
+    using SafeMath for uint256;
+
+    uint256 private _openingTime;
+    uint256 private _closingTime;
+
+    /**
+     * Event for crowdsale extending
+     * @param newClosingTime new closing time
+     * @param prevClosingTime old closing time
+     */
+    event TimedCrowdsaleExtended(uint256 prevClosingTime, uint256 newClosingTime);
+
+    /**
+     * @dev Reverts if not in crowdsale time range.
+     */
+    modifier onlyWhileOpen {
+        require(isOpen(), "TimedCrowdsale: not open");
+        _;
+    }
+
+    /**
+     * @dev Constructor, takes crowdsale opening and closing times.
+     * @param openingTime Crowdsale opening time
+     * @param closingTime Crowdsale closing time
+     */
+    constructor (uint256 openingTime, uint256 closingTime) public {
+        // solhint-disable-next-line not-rely-on-time
+        require(openingTime >= block.timestamp, "TimedCrowdsale: opening time is before current time");
+        // solhint-disable-next-line max-line-length
+        require(closingTime > openingTime, "TimedCrowdsale: opening time is not before closing time");
+
+        _openingTime = openingTime;
+        _closingTime = closingTime;
+    }
+
+    /**
+     * @return the crowdsale opening time.
+     */
+    function openingTime() public view returns (uint256) {
+        return _openingTime;
+    }
+
+    /**
+     * @return the crowdsale closing time.
+     */
+    function closingTime() public view returns (uint256) {
+        return _closingTime;
+    }
+
+    /**
+     * @return true if the crowdsale is open, false otherwise.
+     */
+    function isOpen() public view returns (bool) {
+        // solhint-disable-next-line not-rely-on-time
+        return block.timestamp >= _openingTime && block.timestamp <= _closingTime;
+    }
+
+    /**
+     * @dev Checks whether the period in which the crowdsale is open has already elapsed.
+     * @return Whether crowdsale period has elapsed
+     */
+    function hasClosed() public view returns (bool) {
+        // solhint-disable-next-line not-rely-on-time
+        return block.timestamp > _closingTime;
+    }
+
+    /**
+     * @dev Extend parent behavior requiring to be within contributing period.
+     * @param beneficiary Token purchaser
+     * @param weiAmount Amount of wei contributed
+     */
+    function _preValidatePurchase(address beneficiary, uint256 weiAmount) internal onlyWhileOpen view {
+        super._preValidatePurchase(beneficiary, weiAmount);
+    }
+
+    /**
+     * @dev Extend crowdsale.
+     * @param newClosingTime Crowdsale closing time
+     */
+    function _extendTime(uint256 newClosingTime) internal {
+        require(!hasClosed(), "TimedCrowdsale: already closed");
+        // solhint-disable-next-line max-line-length
+        require(newClosingTime > _closingTime, "TimedCrowdsale: new closing time is before current closing time");
+
+        emit TimedCrowdsaleExtended(_closingTime, newClosingTime);
+        _closingTime = newClosingTime;
+    }
+}

contracts/crowdsale/validation/WhitelistCrowdsale.sol

@@ -0,0 +1,21 @@
+pragma solidity ^0.5.0;
+import "../Crowdsale.sol";
+import "../../access/roles/WhitelistedRole.sol";
+
+
+/**
+ * @title WhitelistCrowdsale
+ * @dev Crowdsale in which only whitelisted users can contribute.
+ */
+contract WhitelistCrowdsale is WhitelistedRole, Crowdsale {
+    /**
+     * @dev Extend parent behavior requiring beneficiary to be whitelisted. Note that no
+     * restriction is imposed on the account sending the transaction.
+     * @param _beneficiary Token beneficiary
+     * @param _weiAmount Amount of wei contributed
+     */
+    function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal view {
+        require(isWhitelisted(_beneficiary), "WhitelistCrowdsale: beneficiary doesn't have the Whitelisted role");
+        super._preValidatePurchase(_beneficiary, _weiAmount);
+    }
+}

contracts/cryptography/ECDSA.sol

@@ -0,0 +1,82 @@
+pragma solidity ^0.5.0;
+
+/**
+ * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
+ *
+ * These functions can be used to verify that a message was signed by the holder
+ * of the private keys of a given address.
+ */
+library ECDSA {
+    /**
+     * @dev Returns the address that signed a hashed message (`hash`) with
+     * `signature`. This address can then be used for verification purposes.
+     *
+     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
+     * this function rejects them by requiring the `s` value to be in the lower
+     * half order, and the `v` value to be either 27 or 28.
+     *
+     * (.note) This call _does not revert_ if the signature is invalid, or
+     * if the signer is otherwise unable to be retrieved. In those scenarios,
+     * the zero address is returned.
+     *
+     * (.warning) `hash` _must_ be the result of a hash operation for the
+     * verification to be secure: it is possible to craft signatures that
+     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
+     * this is by receiving a hash of the original message (which may otherwise)
+     * be too long), and then calling `toEthSignedMessageHash` on it.
+     */
+    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
+        // Check the signature length
+        if (signature.length != 65) {
+            return (address(0));
+        }
+
+        // Divide the signature in r, s and v variables
+        bytes32 r;
+        bytes32 s;
+        uint8 v;
+
+        // ecrecover takes the signature parameters, and the only way to get them
+        // currently is to use assembly.
+        // solhint-disable-next-line no-inline-assembly
+        assembly {
+            r := mload(add(signature, 0x20))
+            s := mload(add(signature, 0x40))
+            v := byte(0, mload(add(signature, 0x60)))
+        }
+
+        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
+        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
+        // the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v in (282): v ∈ {27, 28}. Most
+        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
+        //
+        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
+        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
+        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
+        // these malleable signatures as well.
+        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
+            return address(0);
+        }
+
+        if (v != 27 && v != 28) {
+            return address(0);
+        }
+
+        // If the signature is valid (and not malleable), return the signer address
+        return ecrecover(hash, v, r, s);
+    }
+
+    /**
+     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
+     * replicates the behavior of the
+     * [`eth_sign`](https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign)
+     * JSON-RPC method.
+     *
+     * See `recover`.
+     */
+    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
+        // 32 is the length in bytes of hash,
+        // enforced by the type signature above
+        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
+    }
+}

contracts/cryptography/MerkleProof.sol

@@ -0,0 +1,31 @@
+pragma solidity ^0.5.0;
+
+/**
+ * @dev These functions deal with verification of Merkle trees (hash trees),
+ */
+library MerkleProof {
+    /**
+     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
+     * defined by `root`. For this, a `proof` must be provided, containing
+     * sibling hashes on the branch from the leaf to the root of the tree. Each
+     * pair of leaves and each pair of pre-images are assumed to be sorted.
+     */
+    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
+        bytes32 computedHash = leaf;
+
+        for (uint256 i = 0; i < proof.length; i++) {
+            bytes32 proofElement = proof[i];
+
+            if (computedHash < proofElement) {
+                // Hash(current computed hash + current element of the proof)
+                computedHash = keccak256(abi.encodePacked(computedHash, proofElement));
+            } else {
+                // Hash(current element of the proof + current computed hash)
+                computedHash = keccak256(abi.encodePacked(proofElement, computedHash));
+            }
+        }
+
+        // Check if the computed hash (root) is equal to the provided root
+        return computedHash == root;
+    }
+}

contracts/cryptography/README.md

@@ -0,0 +1,9 @@
+---
+sections:
+  - title: Libraries
+    contracts:
+      - ECDSA
+      - MerkleProof
+---
+
+This collection of libraries provides simple and safe ways to use different cryptographic primitives.

contracts/drafts/Counters.sol

@@ -1,17 +1,21 @@
-// SPDX-License-Identifier: MIT
-// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)
+pragma solidity ^0.5.0;
 
-pragma solidity ^0.8.0;
+import "../math/SafeMath.sol";
 
 /**
  * @title Counters
  * @author Matt Condon (@shrugs)
- * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
+ * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
  * of elements in a mapping, issuing ERC721 ids, or counting request ids.
  *
  * Include with `using Counters for Counters.Counter;`
+ * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the SafeMath
+ * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
+ * directly accessed.
  */
 library Counters {
+    using SafeMath for uint256;
+
     struct Counter {
         // This variable should never be directly accessed by users of the library: interactions must be restricted to
         // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
@@ -24,20 +28,10 @@ library Counters {
     }
 
     function increment(Counter storage counter) internal {
-        unchecked {
-            counter._value += 1;
-        }
+        counter._value += 1;
     }
 
     function decrement(Counter storage counter) internal {
-        uint256 value = counter._value;
-        require(value > 0, "Counter: decrement overflow");
-        unchecked {
-            counter._value = value - 1;
-        }
-    }
-
-    function reset(Counter storage counter) internal {
-        counter._value = 0;
+        counter._value = counter._value.sub(1);
     }
 }

contracts/drafts/ERC1046/ERC20Metadata.sol

@@ -0,0 +1,24 @@
+pragma solidity ^0.5.0;
+
+import "../../token/ERC20/IERC20.sol";
+
+/**
+ * @title ERC-1047 Token Metadata
+ * @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 {
+    string private _tokenURI;
+
+    constructor (string memory tokenURI_) public {
+        _setTokenURI(tokenURI_);
+    }
+
+    function tokenURI() external view returns (string memory) {
+        return _tokenURI;
+    }
+
+    function _setTokenURI(string memory tokenURI_) internal {
+        _tokenURI = tokenURI_;
+    }
+}

contracts/drafts/ERC20Migrator.sol

@@ -0,0 +1,102 @@
+pragma solidity ^0.5.0;
+
+import "../token/ERC20/IERC20.sol";
+import "../token/ERC20/ERC20Mintable.sol";
+import "../token/ERC20/SafeERC20.sol";
+import "../math/Math.sol";
+
+/**
+ * @title ERC20Migrator
+ * @dev This contract can be used to migrate an ERC20 token from one
+ * contract to another, where each token holder has to opt-in to the migration.
+ * To opt-in, users must approve for this contract the number of tokens they
+ * want to migrate. Once the allowance is set up, anyone can trigger the
+ * migration to the new token contract. In this way, token holders "turn in"
+ * their old balance and will be minted an equal amount in the new token.
+ * The new token contract must be mintable. For the precise interface refer to
+ * OpenZeppelin's ERC20Mintable, but the only functions that are needed are
+ * `isMinter(address)` and `mint(address, amount)`. The migrator will check
+ * that it is a minter for the token.
+ * The balance from the legacy token will be transferred to the migrator, as it
+ * is migrated, and remain there forever.
+ * Although this contract can be used in many different scenarios, the main
+ * motivation was to provide a way to migrate ERC20 tokens into an upgradeable
+ * version of it using ZeppelinOS. To read more about how this can be done
+ * using this implementation, please follow the official documentation site of
+ * ZeppelinOS: https://docs.zeppelinos.org/docs/erc20_onboarding.html
+ * Example of usage:
+ * ```
+ * const migrator = await ERC20Migrator.new(legacyToken.address);
+ * await newToken.addMinter(migrator.address);
+ * await migrator.beginMigration(newToken.address);
+ * ```
+ */
+contract ERC20Migrator {
+    using SafeERC20 for IERC20;
+
+    /// Address of the old token contract
+    IERC20 private _legacyToken;
+
+    /// Address of the new token contract
+    ERC20Mintable private _newToken;
+
+    /**
+     * @param legacyToken address of the old token contract
+     */
+    constructor (IERC20 legacyToken) public {
+        require(address(legacyToken) != address(0), "ERC20Migrator: legacy token is the zero address");
+        _legacyToken = legacyToken;
+    }
+
+    /**
+     * @dev Returns the legacy token that is being migrated.
+     */
+    function legacyToken() public view returns (IERC20) {
+        return _legacyToken;
+    }
+
+    /**
+     * @dev Returns the new token to which we are migrating.
+     */
+    function newToken() public view returns (IERC20) {
+        return _newToken;
+    }
+
+    /**
+     * @dev Begins the migration by setting which is the new token that will be
+     * minted. This contract must be a minter for the new token.
+     * @param newToken_ the token that will be minted
+     */
+    function beginMigration(ERC20Mintable newToken_) public {
+        require(address(_newToken) == address(0), "ERC20Migrator: migration already started");
+        require(address(newToken_) != address(0), "ERC20Migrator: new token is the zero address");
+        //solhint-disable-next-line max-line-length
+        require(newToken_.isMinter(address(this)), "ERC20Migrator: not a minter for new token");
+
+        _newToken = newToken_;
+    }
+
+    /**
+     * @dev Transfers part of an account's balance in the old token to this
+     * contract, and mints the same amount of new tokens for that account.
+     * @param account whose tokens will be migrated
+     * @param amount amount of tokens to be migrated
+     */
+    function migrate(address account, uint256 amount) public {
+        require(address(_newToken) != address(0), "ERC20Migrator: migration not started");
+        _legacyToken.safeTransferFrom(account, address(this), amount);
+        _newToken.mint(account, amount);
+    }
+
+    /**
+     * @dev Transfers all of an account's allowed balance in the old token to
+     * this contract, and mints the same amount of new tokens for that account.
+     * @param account whose tokens will be migrated
+     */
+    function migrateAll(address account) public {
+        uint256 balance = _legacyToken.balanceOf(account);
+        uint256 allowance = _legacyToken.allowance(account, address(this));
+        uint256 amount = Math.min(balance, allowance);
+        migrate(account, amount);
+    }
+}

contracts/drafts/ERC20Snapshot.sol

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

contracts/drafts/README.md

@@ -0,0 +1,16 @@
+---
+sections:
+  - title: ERC 20
+    contracts:
+    - ERC20Migrator
+    - ERC20Snapshot
+    - TokenVesting
+  - title: Miscellenous
+    contracts:
+    - Counters
+    - SignatureBouncer
+    - SignedSafeMath
+  - subdirectory: ERC1046
+---
+
+> This page is incomplete. We're working to improve it for the next release. Stay tuned!

contracts/drafts/SignatureBouncer.sol

@@ -0,0 +1,122 @@
+pragma solidity ^0.5.0;
+
+import "../access/roles/SignerRole.sol";
+import "../cryptography/ECDSA.sol";
+
+/**
+ * @title SignatureBouncer
+ * @author PhABC, Shrugs and aflesher
+ * @dev SignatureBouncer allows users to submit a signature as a permission to
+ * do an action.
+ * If the signature is from one of the authorized signer addresses, the
+ * signature is valid.
+ * Note that SignatureBouncer offers no protection against replay attacks, users
+ * must add this themselves!
+ *
+ * Signer addresses can be individual servers signing grants or different
+ * users within a decentralized club that have permission to invite other
+ * members. This technique is useful for whitelists and airdrops; instead of
+ * putting all valid addresses on-chain, simply sign a grant of the form
+ * keccak256(abi.encodePacked(`:contractAddress` + `:granteeAddress`)) using a
+ * valid signer address.
+ * Then restrict access to your crowdsale/whitelist/airdrop using the
+ * `onlyValidSignature` modifier (or implement your own using _isValidSignature).
+ * In addition to `onlyValidSignature`, `onlyValidSignatureAndMethod` and
+ * `onlyValidSignatureAndData` can be used to restrict access to only a given
+ * method or a given method with given parameters respectively.
+ * See the tests in SignatureBouncer.test.js for specific usage examples.
+ *
+ * @notice A method that uses the `onlyValidSignatureAndData` modifier must make
+ * the _signature parameter the "last" parameter. You cannot sign a message that
+ * has its own signature in it so the last 128 bytes of msg.data (which
+ * represents the length of the _signature data and the _signature data itself)
+ * is ignored when validating. Also non fixed sized parameters make constructing
+ * the data in the signature much more complex.
+ * See https://ethereum.stackexchange.com/a/50616 for more details.
+ */
+contract SignatureBouncer is SignerRole {
+    using ECDSA for bytes32;
+
+    // Function selectors are 4 bytes long, as documented in
+    // https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector
+    uint256 private constant _METHOD_ID_SIZE = 4;
+    // 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
+    }
+
+    /**
+     * @dev Requires that a valid signature of a signer was provided.
+     */
+    modifier onlyValidSignature(bytes memory signature) {
+        require(_isValidSignature(msg.sender, signature), "SignatureBouncer: invalid signature for caller");
+        _;
+    }
+
+    /**
+     * @dev Requires that a valid signature with a specified method of a signer was provided.
+     */
+    modifier onlyValidSignatureAndMethod(bytes memory signature) {
+        // solhint-disable-next-line max-line-length
+        require(_isValidSignatureAndMethod(msg.sender, signature), "SignatureBouncer: invalid signature for caller and method");
+        _;
+    }
+
+    /**
+     * @dev Requires that a valid signature with a specified method and params of a signer was provided.
+     */
+    modifier onlyValidSignatureAndData(bytes memory signature) {
+        // solhint-disable-next-line max-line-length
+        require(_isValidSignatureAndData(msg.sender, signature), "SignatureBouncer: invalid signature for caller and data");
+        _;
+    }
+
+    /**
+     * @dev is the signature of `this + account` from a signer?
+     * @return bool
+     */
+    function _isValidSignature(address account, bytes memory signature) internal view returns (bool) {
+        return _isValidDataHash(keccak256(abi.encodePacked(address(this), account)), signature);
+    }
+
+    /**
+     * @dev is the signature of `this + account + methodId` from a signer?
+     * @return bool
+     */
+    function _isValidSignatureAndMethod(address account, bytes memory signature) internal view returns (bool) {
+        bytes memory data = new bytes(_METHOD_ID_SIZE);
+        for (uint i = 0; i < data.length; i++) {
+            data[i] = msg.data[i];
+        }
+        return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
+    }
+
+    /**
+     * @dev is the signature of `this + account + methodId + params(s)` from a signer?
+     * @notice the signature parameter of the method being validated must be the "last" parameter
+     * @return bool
+     */
+    function _isValidSignatureAndData(address account, bytes memory signature) internal view returns (bool) {
+        require(msg.data.length > _SIGNATURE_SIZE, "SignatureBouncer: data is too short");
+
+        bytes memory data = new bytes(msg.data.length - _SIGNATURE_SIZE);
+        for (uint i = 0; i < data.length; i++) {
+            data[i] = msg.data[i];
+        }
+
+        return _isValidDataHash(keccak256(abi.encodePacked(address(this), account, data)), signature);
+    }
+
+    /**
+     * @dev Internal function to convert a hash to an eth signed message
+     * and then recover the signature and check it against the signer role.
+     * @return bool
+     */
+    function _isValidDataHash(bytes32 hash, bytes memory signature) internal view returns (bool) {
+        address signer = hash.toEthSignedMessageHash().recover(signature);
+
+        return signer != address(0) && isSigner(signer);
+    }
+}