From da7fd0d3e5a99120800b649472852b7db256b285 Mon Sep 17 00:00:00 2001 From: github-actions <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 22 Apr 2025 16:39:54 +0000 Subject: [PATCH] Update docs --- .githooks/pre-push | 8 - .github/actions/gas-compare/action.yml | 11 +- .github/actions/setup/action.yml | 2 +- .github/actions/storage-layout/action.yml | 3 +- .github/workflows/checks.yml | 8 +- .github/workflows/formal-verification.yml | 2 +- .gitignore | 1 + .husky/pre-commit | 2 + CHANGELOG.md | 65 +- FUNDING.json | 3 + GUIDELINES.md | 2 +- LICENSE | 2 +- README.md | 4 +- RELEASING.md | 4 +- SECURITY.md | 2 +- audits/2017-03.md | 10 +- audits/2024-12-v5.2.pdf | Bin 0 -> 242253 bytes audits/README.md | 17 +- certora/README.md | 4 +- certora/run.js | 44 +- .../specs/AccessControlDefaultAdminRules.spec | 4 +- certora/specs/ERC20FlashMint.spec | 6 +- contracts/access/AccessControl.sol | 4 +- contracts/access/IAccessControl.sol | 4 +- contracts/access/manager/AuthorityUtils.sol | 24 +- .../account/utils/draft-ERC4337Utils.sol | 63 +- .../account/utils/draft-ERC7579Utils.sol | 8 +- contracts/finance/VestingWallet.sol | 4 +- contracts/governance/Governor.sol | 49 +- contracts/governance/IGovernor.sol | 27 +- contracts/governance/README.adoc | 20 +- contracts/governance/TimelockController.sol | 4 +- .../extensions/GovernorCountingFractional.sol | 8 +- .../GovernorCountingOverridable.sol | 36 +- .../extensions/GovernorProposalGuardian.sol | 58 + .../GovernorSequentialProposalId.sol | 77 + .../governance/extensions/GovernorStorage.sol | 4 +- .../extensions/GovernorSuperQuorum.sol | 60 + .../extensions/GovernorTimelockAccess.sol | 4 +- .../extensions/GovernorTimelockCompound.sol | 4 +- .../extensions/GovernorTimelockControl.sol | 4 +- .../GovernorVotesQuorumFraction.sol | 31 +- .../GovernorVotesSuperQuorumFraction.sol | 134 ++ contracts/interfaces/IERC1271.sol | 4 +- contracts/interfaces/IERC4626.sol | 4 +- contracts/interfaces/README.adoc | 16 +- contracts/interfaces/draft-IERC4337.sol | 8 +- contracts/interfaces/draft-IERC6909.sol | 125 + contracts/interfaces/draft-IERC7579.sol | 14 +- contracts/metatx/ERC2771Forwarder.sol | 7 +- contracts/mocks/AuthorityMock.sol | 10 +- contracts/mocks/MerkleTreeMock.sol | 8 + .../access-control/AccessControlModified.sol | 4 +- .../docs/token/ERC6909/ERC6909GameItems.sol | 26 + .../GovernorProposalGuardianMock.sol | 27 + .../GovernorSequentialProposalIdMock.sol | 39 + .../governance/GovernorSuperQuorumMock.sol | 95 + .../GovernorVotesSuperQuorumFractionMock.sol | 37 + .../mocks/token/ERC20ForceApproveMock.sol | 2 +- contracts/package.json | 2 +- contracts/proxy/Clones.sol | 8 +- contracts/proxy/utils/Initializable.sol | 16 +- contracts/proxy/utils/UUPSUpgradeable.sol | 3 +- contracts/token/ERC1155/IERC1155.sol | 6 +- .../token/ERC1155/utils/ERC1155Utils.sol | 6 +- contracts/token/ERC20/ERC20.sol | 9 +- contracts/token/ERC20/README.adoc | 10 +- contracts/token/ERC20/extensions/ERC4626.sol | 14 +- .../draft-ERC20TemporaryApproval.sol | 4 +- contracts/token/ERC20/utils/SafeERC20.sol | 16 +- contracts/token/ERC6909/README.adoc | 27 + contracts/token/ERC6909/draft-ERC6909.sol | 224 ++ .../extensions/draft-ERC6909ContentURI.sol | 53 + .../extensions/draft-ERC6909Metadata.sol | 77 + .../extensions/draft-ERC6909TokenSupply.sol | 35 + contracts/token/ERC721/README.adoc | 4 +- .../ERC721/extensions/ERC721Consecutive.sol | 4 +- .../ERC721/extensions/ERC721URIStorage.sol | 4 +- contracts/token/ERC721/utils/ERC721Utils.sol | 4 +- contracts/token/common/ERC2981.sol | 4 +- contracts/utils/Arrays.sol | 8 +- contracts/utils/Calldata.sol | 25 + contracts/utils/Multicall.sol | 6 +- contracts/utils/Pausable.sol | 9 +- contracts/utils/README.adoc | 17 +- contracts/utils/ReentrancyGuardTransient.sol | 4 +- contracts/utils/ShortStrings.sol | 6 +- contracts/utils/SlotDerivation.sol | 4 +- contracts/utils/Strings.sol | 69 +- contracts/utils/TransientSlot.sol | 12 +- contracts/utils/cryptography/EIP712.sol | 6 +- contracts/utils/cryptography/Hashes.sol | 6 +- .../utils/cryptography/MessageHashUtils.sol | 21 +- contracts/utils/cryptography/P256.sol | 44 +- contracts/utils/math/Math.sol | 258 +- contracts/utils/structs/Checkpoints.sol | 8 +- contracts/utils/structs/CircularBuffer.sol | 4 +- contracts/utils/structs/EnumerableMap.sol | 97 +- contracts/utils/structs/EnumerableSet.sol | 49 +- contracts/utils/structs/MerkleTree.sol | 98 +- docs/modules/ROOT/nav.adoc | 1 + docs/modules/ROOT/pages/access-control.adoc | 2 +- docs/modules/ROOT/pages/crowdsales.adoc | 11 - docs/modules/ROOT/pages/drafts.adoc | 19 - docs/modules/ROOT/pages/erc1155.adoc | 2 +- docs/modules/ROOT/pages/erc20-supply.adoc | 2 +- docs/modules/ROOT/pages/erc6909.adoc | 47 + docs/modules/ROOT/pages/governance.adoc | 4 +- docs/modules/ROOT/pages/index.adoc | 2 +- docs/modules/ROOT/pages/utilities.adoc | 8 +- .../access-control/AccessControlModified.sol | 4 +- .../token/ERC6909/ERC6909GameItems.sol | 26 + docs/modules/api/nav.adoc | 1 + docs/modules/api/pages/access.adoc | 197 +- docs/modules/api/pages/account.adoc | 64 +- docs/modules/api/pages/finance.adoc | 19 +- docs/modules/api/pages/governance.adoc | 2092 ++++++++++++++++- docs/modules/api/pages/interfaces.adoc | 599 ++++- docs/modules/api/pages/metatx.adoc | 36 +- docs/modules/api/pages/proxy.adoc | 100 +- docs/modules/api/pages/token/ERC1155.adoc | 85 +- docs/modules/api/pages/token/ERC20.adoc | 189 +- docs/modules/api/pages/token/ERC6909.adoc | 891 +++++++ docs/modules/api/pages/token/ERC721.adoc | 133 +- docs/modules/api/pages/token/common.adoc | 12 +- docs/modules/api/pages/utils.adoc | 1425 ++++++++++- docs/templates/contract.hbs | 4 + docs/templates/properties.js | 16 + fv-requirements.txt | 2 +- hardhat.config.js | 2 +- hardhat/async-test-sanity.js | 9 +- hardhat/common-contracts.js | 63 + hardhat/ignore-unreachable-warnings.js | 2 +- lib/forge-std | 2 +- package-lock.json | 1243 +++++++--- package.json | 30 +- scripts/checks/coverage.sh | 8 +- scripts/checks/inheritance-ordering.js | 2 +- scripts/checks/pragma-consistency.js | 2 +- scripts/fetch-common-contracts.js | 50 + scripts/generate/templates/Arrays.js | 2 +- scripts/generate/templates/Checkpoints.js | 2 +- scripts/generate/templates/Checkpoints.t.js | 4 +- scripts/generate/templates/EnumerableMap.js | 25 + scripts/generate/templates/EnumerableSet.js | 27 + scripts/generate/templates/SlotDerivation.js | 2 +- .../generate/templates/SlotDerivation.t.js | 8 +- scripts/generate/templates/TransientSlot.js | 2 +- scripts/prepare-docs.sh | 2 +- scripts/prepare.sh | 5 - scripts/release/format-changelog.js | 2 +- scripts/set-max-old-space-size.sh | 10 + scripts/solhint-custom/package.json | 5 +- scripts/upgradeable/upgradeable.patch | 22 +- slither.config.json | 3 +- solhint.config.js | 2 +- test/TESTING.md | 2 +- test/access/AccessControl.behavior.js | 2 +- test/access/manager/AuthorityUtils.test.js | 12 +- test/account/utils/draft-ERC4337Utils.test.js | 119 +- test/account/utils/draft-ERC7579Utils.t.sol | 17 +- test/account/utils/draft-ERC7579Utils.test.js | 106 +- test/bin/EntryPoint080.abi | 1 + test/bin/EntryPoint080.bytecode | Bin 0 -> 21738 bytes test/bin/SenderCreator080.abi | 1 + test/bin/SenderCreator080.bytecode | Bin 0 -> 1217 bytes test/governance/Governor.t.sol | 8 +- test/governance/Governor.test.js | 38 +- .../GovernorCountingFractional.test.js | 2 +- .../GovernorCountingOverridable.test.js | 2 +- .../extensions/GovernorERC721.test.js | 2 +- .../GovernorPreventLateQuorum.test.js | 2 +- .../GovernorProposalGuardian.test.js | 132 ++ .../GovernorSequentialProposalId.test.js | 202 ++ .../extensions/GovernorStorage.test.js | 2 +- .../extensions/GovernorSuperQuorum.test.js | 168 ++ ...GovernorSuperQuorumGreaterThanQuorum.t.sol | 79 + .../extensions/GovernorTimelockAccess.test.js | 2 +- .../GovernorTimelockCompound.test.js | 2 +- .../GovernorTimelockControl.test.js | 2 +- .../GovernorVotesQuorumFraction.test.js | 2 +- .../GovernorVotesSuperQuorumFraction.test.js | 160 ++ .../extensions/GovernorWithParams.test.js | 2 +- test/helpers/constants.js | 1 + test/helpers/enums.js | 12 +- test/helpers/erc4337-entrypoint.js | 31 - test/helpers/erc4337.js | 22 +- test/helpers/governance.js | 26 +- test/helpers/iterate.js | 9 +- test/helpers/precompiles.js | 12 + test/helpers/time.js | 7 +- test/metatx/ERC2771Context.test.js | 4 +- test/metatx/ERC2771Forwarder.t.sol | 6 +- test/proxy/Clones.t.sol | 6 +- test/proxy/beacon/BeaconProxy.test.js | 2 +- .../ERC20/extensions/ERC20Wrapper.test.js | 4 +- test/token/ERC20/extensions/ERC4626.test.js | 12 +- test/token/ERC20/utils/SafeERC20.test.js | 36 + test/token/ERC6909/ERC6909.behavior.js | 216 ++ test/token/ERC6909/ERC6909.test.js | 104 + .../extensions/ERC6909ContentURI.test.js | 49 + .../extensions/ERC6909Metadata.test.js | 58 + .../extensions/ERC6909TokenSupply.test.js | 53 + test/token/ERC721/ERC721.behavior.js | 26 - .../extensions/ERC721Consecutive.test.js | 8 - test/utils/Arrays.t.sol | 6 +- test/utils/Base64.t.sol | 4 +- test/utils/Calldata.test.js | 22 + test/utils/Create2.t.sol | 2 +- test/utils/Nonces.behavior.js | 50 +- test/utils/ShortStrings.t.sol | 12 +- test/utils/SlotDerivation.t.sol | 28 +- test/utils/Strings.t.sol | 8 +- test/utils/Strings.test.js | 7 + .../utils/cryptography/MessageHashUtils.t.sol | 33 + .../cryptography/MessageHashUtils.test.js | 39 +- test/utils/cryptography/P256.t.sol | 26 +- test/utils/cryptography/P256.test.js | 86 +- .../cryptography/SignatureChecker.test.js | 28 +- .../SupportsInterface.behavior.js | 87 +- test/utils/math/Math.t.sol | 114 +- test/utils/math/Math.test.js | 445 ++-- test/utils/math/SignedMath.t.sol | 14 +- test/utils/structs/Checkpoints.t.sol | 12 +- test/utils/structs/EnumerableMap.behavior.js | 43 + test/utils/structs/EnumerableMap.test.js | 1 + test/utils/structs/EnumerableSet.behavior.js | 45 +- test/utils/structs/EnumerableSet.test.js | 1 + test/utils/structs/Heap.t.sol | 2 +- test/utils/structs/MerkleTree.test.js | 136 +- 230 files changed, 11375 insertions(+), 1714 deletions(-) delete mode 100755 .githooks/pre-push create mode 100755 .husky/pre-commit create mode 100644 audits/2024-12-v5.2.pdf create mode 100644 contracts/governance/extensions/GovernorProposalGuardian.sol create mode 100644 contracts/governance/extensions/GovernorSequentialProposalId.sol create mode 100644 contracts/governance/extensions/GovernorSuperQuorum.sol create mode 100644 contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol create mode 100644 contracts/interfaces/draft-IERC6909.sol create mode 100644 contracts/mocks/docs/token/ERC6909/ERC6909GameItems.sol create mode 100644 contracts/mocks/governance/GovernorProposalGuardianMock.sol create mode 100644 contracts/mocks/governance/GovernorSequentialProposalIdMock.sol create mode 100644 contracts/mocks/governance/GovernorSuperQuorumMock.sol create mode 100644 contracts/mocks/governance/GovernorVotesSuperQuorumFractionMock.sol create mode 100644 contracts/token/ERC6909/README.adoc create mode 100644 contracts/token/ERC6909/draft-ERC6909.sol create mode 100644 contracts/token/ERC6909/extensions/draft-ERC6909ContentURI.sol create mode 100644 contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol create mode 100644 contracts/token/ERC6909/extensions/draft-ERC6909TokenSupply.sol create mode 100644 contracts/utils/Calldata.sol delete mode 100644 docs/modules/ROOT/pages/crowdsales.adoc delete mode 100644 docs/modules/ROOT/pages/drafts.adoc create mode 100644 docs/modules/ROOT/pages/erc6909.adoc create mode 100644 docs/modules/api/examples/token/ERC6909/ERC6909GameItems.sol create mode 100644 docs/modules/api/pages/token/ERC6909.adoc create mode 100644 hardhat/common-contracts.js create mode 100755 scripts/fetch-common-contracts.js delete mode 100755 scripts/prepare.sh create mode 100755 scripts/set-max-old-space-size.sh create mode 100644 test/bin/EntryPoint080.abi create mode 100644 test/bin/EntryPoint080.bytecode create mode 100644 test/bin/SenderCreator080.abi create mode 100644 test/bin/SenderCreator080.bytecode create mode 100644 test/governance/extensions/GovernorProposalGuardian.test.js create mode 100644 test/governance/extensions/GovernorSequentialProposalId.test.js create mode 100644 test/governance/extensions/GovernorSuperQuorum.test.js create mode 100644 test/governance/extensions/GovernorSuperQuorumGreaterThanQuorum.t.sol create mode 100644 test/governance/extensions/GovernorVotesSuperQuorumFraction.test.js delete mode 100644 test/helpers/erc4337-entrypoint.js create mode 100644 test/helpers/precompiles.js create mode 100644 test/token/ERC6909/ERC6909.behavior.js create mode 100644 test/token/ERC6909/ERC6909.test.js create mode 100644 test/token/ERC6909/extensions/ERC6909ContentURI.test.js create mode 100644 test/token/ERC6909/extensions/ERC6909Metadata.test.js create mode 100644 test/token/ERC6909/extensions/ERC6909TokenSupply.test.js create mode 100644 test/utils/Calldata.test.js create mode 100644 test/utils/cryptography/MessageHashUtils.t.sol diff --git a/.githooks/pre-push b/.githooks/pre-push deleted file mode 100755 index f028ce58e..000000000 --- a/.githooks/pre-push +++ /dev/null @@ -1,8 +0,0 @@ -#!/usr/bin/env bash - -set -euo pipefail - -if [ "${CI:-"false"}" != "true" ]; then - npm run test:generation - npm run lint -fi diff --git a/.github/actions/gas-compare/action.yml b/.github/actions/gas-compare/action.yml index 23a756f3d..78c286c94 100644 --- a/.github/actions/gas-compare/action.yml +++ b/.github/actions/gas-compare/action.yml @@ -2,18 +2,18 @@ name: Compare gas costs description: Compare gas costs between branches inputs: token: - description: github token + description: GitHub token, required to access GitHub API required: true report: - description: report to read from + description: Path to the report to compare required: false default: gasReporterOutput.json out_report: - description: report to read + description: Path to save the output report required: false default: ${{ github.ref_name }}.gasreport.json ref_report: - description: report to read from + description: Path to the reference report for comparison required: false default: ${{ github.base_ref }}.gasreport.json @@ -44,7 +44,8 @@ runs: shell: bash - name: Save report if: github.event_name != 'pull_request' - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: gasreport + overwrite: true path: ${{ inputs.out_report }} diff --git a/.github/actions/setup/action.yml b/.github/actions/setup/action.yml index b68fec649..3c5fc602e 100644 --- a/.github/actions/setup/action.yml +++ b/.github/actions/setup/action.yml @@ -19,4 +19,4 @@ runs: - name: Install Foundry uses: foundry-rs/foundry-toolchain@v1 with: - version: nightly + version: stable diff --git a/.github/actions/storage-layout/action.yml b/.github/actions/storage-layout/action.yml index 573564b67..fb68d5f6b 100644 --- a/.github/actions/storage-layout/action.yml +++ b/.github/actions/storage-layout/action.yml @@ -50,7 +50,8 @@ runs: shell: bash - name: Save artifacts if: github.event_name != 'pull_request' - uses: actions/upload-artifact@v3 + uses: actions/upload-artifact@v4 with: name: layout + overwrite: true path: ${{ inputs.out_layout }} diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml index 18a38b3c5..6700832b6 100644 --- a/.github/workflows/checks.yml +++ b/.github/workflows/checks.yml @@ -43,7 +43,7 @@ jobs: run: npm run test:inheritance - name: Check pragma consistency between files run: npm run test:pragma - - name: Check proceduraly generated contracts are up-to-date + - name: Check procedurally generated contracts are up-to-date run: npm run test:generation - name: Compare gas costs uses: ./.github/actions/gas-compare @@ -97,7 +97,7 @@ jobs: uses: ./.github/actions/setup - name: Run coverage run: npm run coverage - - uses: codecov/codecov-action@v4 + - uses: codecov/codecov-action@v5 env: CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }} @@ -118,11 +118,7 @@ jobs: - uses: actions/checkout@v4 - name: Set up environment uses: ./.github/actions/setup - - run: rm foundry.toml - uses: crytic/slither-action@v0.4.0 - with: - node-version: 18.15 - slither-version: 0.10.1 codespell: runs-on: ubuntu-latest diff --git a/.github/workflows/formal-verification.yml b/.github/workflows/formal-verification.yml index e0475b195..86acca7f3 100644 --- a/.github/workflows/formal-verification.yml +++ b/.github/workflows/formal-verification.yml @@ -52,7 +52,7 @@ jobs: - name: Install python packages run: pip install -r fv-requirements.txt - name: Install java - uses: actions/setup-java@v3 + uses: actions/setup-java@v4 with: distribution: temurin java-version: ${{ env.JAVA_VERSION }} diff --git a/.gitignore b/.gitignore index b2b1eab1e..50f1bf5b7 100644 --- a/.gitignore +++ b/.gitignore @@ -37,6 +37,7 @@ npm-debug.log # docs artifacts docs/modules/api +build/site # only used to package @openzeppelin/contracts contracts/build/ diff --git a/.husky/pre-commit b/.husky/pre-commit new file mode 100755 index 000000000..4738b0555 --- /dev/null +++ b/.husky/pre-commit @@ -0,0 +1,2 @@ +npm run test:generation +npx lint-staged diff --git a/CHANGELOG.md b/CHANGELOG.md index 3b5eb8448..0d6e04e24 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,64 @@ # Changelog +## 5.3.0 (2025-04-09) + +### Breaking Changes + +- Replace `GovernorCountingOverridable.VoteReceipt` struct parameter member names `hasOverriden` and `overridenWeight` for `hasOverridden` and `overriddenWeight` respectively. + +#### Custom error changes + +- Replace `AccessControlNonRevokable` with `AccessControlNonRevocable`. +- Replace `GovernorAlreadyOverridenVote` with `GovernorAlreadyOverriddenVote`. +- Replace `GovernorOnlyProposer` with `GovernorUnableToCancel`. + +### Changes by category + +#### Account + +- `ERC4337Utils`: Update the `hash` function to call `getUserOpHash` on the specified entrypoint and add an `ENTRYPOINT_V08` constant. ([#5614](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5614)) +- `ERC7579Utils`: Add ABI decoding checks on calldata bounds within `decodeBatch`. ([#5371](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5371)) +- `ERC7579Utils`: Replace `address(0)` with `address(this)` during execution for calldata compression efficiency. ([#5614](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5614)) + +#### Governance + +- `IGovernor`: Add the `getProposalId` function to the governor interface. ([#5290](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5290)) +- `GovernorProposalGuardian`: Add a governance extension that defines a proposal guardian who can cancel proposals at any stage in their lifecycle. ([#5303](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5303)) +- `GovernorSequentialProposalId`: Adds a `Governor` extension that sequentially numbers proposal ids instead of using the hash. ([#5290](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5290)) +- `GovernorSuperQuorum`: Add a governance extension to support a super quorum. Proposals that meet the super quorum (and have a majority of for votes) advance to the `Succeeded` state before the proposal deadline. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) +- `GovernorVotesSuperQuorumFraction`: Add a variant of the `GovernorSuperQuorum` extensions where the super quorum is expressed as a fraction of the total supply. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) +- `TimelockController`: Receive function is now virtual. ([#5509](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5509)) + +#### Structures + +- `EnumerableSet`: Add `clear` function to EnumerableSets which deletes all values in the set. ([#5486](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5486)) +- `EnumerableMap`: Add `clear` function to EnumerableMaps which deletes all entries in the map. ([#5486](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5486)) +- `MerkleTree`: Add an update function that replaces a previously inserted leaf with a new value, updating the tree root along the way. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) + +#### Tokens + +- `ERC4626`: Use the `asset` getter in `totalAssets`, `_deposit` and `_withdraw`. ([#5322](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5322)) +- `IERC6909`: Add the interface for ERC-6909. ([#5343](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5343)) +- `ERC6909`: Add a standard implementation of ERC6909. ([#5394](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5394)) +- `ERC6909TokenSupply`: Add an extension of ERC6909 which tracks total supply for each token id. ([#5394](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5394)) +- `ERC6909Metadata`: Add an extension of ERC6909 which adds metadata functionality. ([#5394](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5394)) +- `ERC6909ContentURI`: Add an extension of ERC6909 which adds content URI functionality. ([#5394](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5394)) +- `SafeERC20`: Add `trySafeTransfer` and `trySafeTransferFrom` that do not revert and return false if the transfer is not successful. ([#5483](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5483)) + +#### Other + +- `Address`: bubble up revert data on `sendValue` failed call. ([#5379](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5379)) +- `Calldata`: Library with `emptyBytes` and `emptyString` functions to generate empty `bytes` and `string` calldata types. ([#5422](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5422)) +- `ERC2771Forwarder`: Expose the `_isTrustedByTarget` internal function to check whether a target trusts the forwarder. ([#5416](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5416)) +- `Hashes`: Expose `efficientKeccak256` for hashing non-commutative pairs of bytes32 without allocating extra memory. ([#5442](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5442)) +- `Initializable`: Add `_initializableStorageSlot` function that returns a pointer to the storage struct. The function allows customizing with a custom storage slot with an `override`. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) +- `Math`: Add `add512`, `mul512` and `mulShr`. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) +- `Math`: Add saturating arithmetic operations `saturatingAdd`, `saturatingSub` and `saturatingMul`. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) +- `MessageHashUtils`: Add `toDataWithIntendedValidatorHash(address, bytes32)`. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) +- `P256`: Adjust precompile detection in `verifyNative` to consider empty `returndata` on invalid verification. Previously, invalid signatures would've reverted with a `MissingPrecompile` error in chains with RIP-7212 support. ([#5620](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5620)) +- `Pausable`: Stop explicitly setting `paused` to `false` during construction. ([#5448](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5448)) +- `Strings`: Add `espaceJSON` that escapes special characters in JSON strings. ([#5526](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5526)) + ## 5.2.0 (2025-01-08) ### Breaking Changes @@ -37,7 +96,7 @@ This version comes with changes to the custom error identifiers. Contracts previ ### Utils - `Address`: bubble up revert data on `sendValue` failed call ([#5418](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5418)) -- `Bytes`: Add a library of common operation that operate on `bytes` objects. ([#5252](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5252)) +- `Bytes`: Add a library of common operations that operate on `bytes` objects. ([#5252](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5252)) - `CAIP2` and `CAIP10`: Add libraries for formatting and parsing CAIP-2 and CAIP-10 identifiers. ([#5252](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5252)) - `NoncesKeyed`: Add a variant of `Nonces` that implements the ERC-4337 entrypoint nonce system. ([#5272](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5272)) - `Packing`: Add variants for packing `bytes10` and `bytes22` ([#5274](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/5274)) @@ -48,7 +107,7 @@ This version comes with changes to the custom error identifiers. Contracts previ ### Breaking changes - `ERC1967Utils`: Removed duplicate declaration of the `Upgraded`, `AdminChanged` and `BeaconUpgraded` events. These events are still available through the `IERC1967` interface located under the `contracts/interfaces/` directory. Minimum pragma version is now 0.8.21. -- `Governor`, `GovernorCountingSimple`: The `_countVote` virtual function now returns an `uint256` with the total votes casted. This change allows for more flexibility for partial and fractional voting. Upgrading users may get a compilation error that can be fixed by adding a return statement to the `_countVote` function. +- `Governor`, `GovernorCountingSimple`: The `_countVote` virtual function now returns an `uint256` with the total votes cast. This change allows for more flexibility for partial and fractional voting. Upgrading users may get a compilation error that can be fixed by adding a return statement to the `_countVote` function. #### Custom error changes @@ -419,7 +478,7 @@ Instead, contracts now revert with custom errors. Systems that interact with sma ##### Relying on storage locations for retrieving data -After 5.0, the storage location of some variables were changed. This is the case for `Initializable` and all the upgradeable contracts since they now use namespaced storaged locations. Any system relying on storage locations for retrieving data or detecting capabilities should be updated to support these new locations. +After 5.0, the storage location of some variables was changed. This is the case for `Initializable` and all the upgradeable contracts since they now use namespaced storage locations. Any system relying on storage locations for retrieving data or detecting capabilities should be updated to support these new locations. ## 4.9.6 (2024-02-29) diff --git a/FUNDING.json b/FUNDING.json index c67286216..0a362ba35 100644 --- a/FUNDING.json +++ b/FUNDING.json @@ -3,5 +3,8 @@ "ethereum": { "ownedBy": "0xAeb37910f93486C85A1F8F994b67E8187554d664" } + }, + "opRetro": { + "projectId": "0x939241afa4c4b9e1dda6b8250baa8f04fa8b0debce738cfd324c0b18f9926d25" } } diff --git a/GUIDELINES.md b/GUIDELINES.md index 2c21e956b..deafed005 100644 --- a/GUIDELINES.md +++ b/GUIDELINES.md @@ -6,7 +6,7 @@ Code must be thoroughly tested with quality unit tests. We defer to the [Moloch Testing Guide](https://github.com/MolochVentures/moloch/tree/master/test#readme) for specific recommendations, though not all of it is relevant here. Note the introduction: -> Tests should be written, not only to verify correctness of the target code, but to be comprehensively reviewed by other programmers. Therefore, for mission critical Solidity code, the quality of the tests are just as important (if not more so) than the code itself, and should be written with the highest standards of clarity and elegance. +> Tests should be written, not only to verify correctness of the target code, but to be comprehensively reviewed by other programmers. Therefore, for mission critical Solidity code, the quality of the tests is just as important (if not more so) than the code itself, and should be written to the highest standards of clarity and elegance. Every addition or change to the code must come with relevant and comprehensive tests. diff --git a/LICENSE b/LICENSE index b2fee8f21..367f411ba 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ The MIT License (MIT) -Copyright (c) 2016-2024 Zeppelin Group Ltd +Copyright (c) 2016-2025 Zeppelin Group Ltd Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the diff --git a/README.md b/README.md index fa7b4e31e..60d0a430a 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ [![Coverage Status](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts/graph/badge.svg)](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts) [![GitPOAPs](https://public-api.gitpoap.io/v1/repo/OpenZeppelin/openzeppelin-contracts/badge)](https://www.gitpoap.io/gh/OpenZeppelin/openzeppelin-contracts) [![Docs](https://img.shields.io/badge/docs-%F0%9F%93%84-yellow)](https://docs.openzeppelin.com/contracts) -[![Forum](https://img.shields.io/badge/forum-%F0%9F%92%AC-yellow)](https://docs.openzeppelin.com/contracts) +[![Forum](https://img.shields.io/badge/forum-%F0%9F%92%AC-yellow)](https://forum.openzeppelin.com/) **A library for secure smart contract development.** Build on a solid foundation of community-vetted code. @@ -70,7 +70,7 @@ The guides in the [documentation site](https://docs.openzeppelin.com/contracts) * [Tokens](https://docs.openzeppelin.com/contracts/tokens): create tradeable assets or collectives, and distribute them via [Crowdsales](https://docs.openzeppelin.com/contracts/crowdsales). * [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). +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' 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/), 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. diff --git a/RELEASING.md b/RELEASING.md index 06dd218e8..6820d403d 100644 --- a/RELEASING.md +++ b/RELEASING.md @@ -1,10 +1,10 @@ # Releasing -OpenZeppelin Contracts uses a fully automated release process that takes care of compiling, packaging, and publishing the library, all of which is carried out in a clean CI environment (GitHub Actions), implemented in the ([`release-cycle`](.github/workflows/release-cycle.yml)) workflow. This helps to reduce the potential for human error and inconsistencies, and ensures that the release process is ongoing and reliable. +OpenZeppelin Contracts uses a fully automated release process that takes care of compiling, packaging, and publishing the library, all of which is carried out in a clean CI environment (GitHub Actions), implemented in the [`release-cycle`](.github/workflows/release-cycle.yml) workflow. This helps to reduce the potential for human error and inconsistencies, and ensures that the release process is consistent and reliable. ## Changesets -[Changesets](https://github.com/changesets/changesets/) is used as part of our release process for `CHANGELOG.md` management. Each change that is relevant for the codebase is expected to include a changeset. +[Changesets](https://github.com/changesets/changesets/) are used as part of our release process for `CHANGELOG.md` management. Each change that is relevant for the codebase is expected to include a changeset. ## Branching model diff --git a/SECURITY.md b/SECURITY.md index 9922c45e7..bea59e1f2 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -40,4 +40,4 @@ Note as well that the Solidity language itself only guarantees security updates ## Legal -Smart contracts are a nascent technology and carry a high level of technical risk and uncertainty. OpenZeppelin Contracts is made available under the MIT License, which disclaims all warranties in relation to the project and which limits the liability of those that contribute and maintain the project, including OpenZeppelin. Your use of the project is also governed by the terms found at www.openzeppelin.com/tos (the "Terms"). As set out in the Terms, you are solely responsible for any use of OpenZeppelin Contracts and you assume all risks associated with any such use. This Security Policy in no way evidences or represents an on-going duty by any contributor, including OpenZeppelin, to correct any flaws or alert you to all or any of the potential risks of utilizing the project. +Smart contracts are a nascent technology and carry a high level of technical risk and uncertainty. OpenZeppelin Contracts is made available under the MIT License, which disclaims all warranties in relation to the project and which limits the liability of those that contribute and maintain the project, including OpenZeppelin. Your use of the project is also governed by the terms found at www.openzeppelin.com/tos (the "Terms"). As set out in the Terms, you are solely responsible for any use of OpenZeppelin Contracts and you assume all risks associated with any such use. This Security Policy in no way evidences or represents an ongoing duty by any contributor, including OpenZeppelin, to correct any flaws or alert you to all or any of the potential risks of utilizing the project. diff --git a/audits/2017-03.md b/audits/2017-03.md index 4cd6dbfd3..d54174ecb 100644 --- a/audits/2017-03.md +++ b/audits/2017-03.md @@ -20,7 +20,7 @@ The git commit hash we evaluated is: # Disclaimer -The audit makes no statements or warrantees about utility of the code, safety of the code, suitability of the business model, regulatory regime for the business model, or any other statements about fitness of the contracts to purpose, or their bugfree status. The audit documentation is for discussion purposes only. +The audit makes no statements or warranties about utility of the code, safety of the code, suitability of the business model, regulatory regime for the business model, or any other statements about fitness of the contracts to purpose, or their bug free status. The audit documentation is for discussion purposes only. # Executive Summary @@ -90,7 +90,7 @@ We are still working through the confirmation protocol in `Shareable.sol`, but w This bug has a number of causes that need to be addressed: 1. `resetSpentToday` and `confirm` together do not limit the days on which the function can be called or (it appears) the number of times it can be called. -1. Once a call has been confirmed and `execute`d it appears that it can be re-executed. This is not good. +1. Once a call has been confirmed and executed it appears that it can be re-executed. This is not good. 3. `confirmandCheck` doesn't seem to have logic about whether or not the function in question has been called. 4. Even if it did, `revoke` would need updates and logic to deal with revocation requests after a function call had been completed. @@ -109,7 +109,7 @@ It would be nice to see how many payments are pending. This would imply a bit of ## Shareable Contract -We do not believe the `Shareable.sol` contract is ready for primetime. It is missing functions, and as written may be vulnerable to a reordering attack -- an attack in which a miner or other party "racing" with a smart contract participant inserts their own information into a list or mapping. +We do not believe the `Shareable.sol` contract is ready for prime time. It is missing functions, and as written may be vulnerable to a reordering attack -- an attack in which a miner or other party "racing" with a smart contract participant inserts their own information into a list or mapping. The confirmation and revocation code needs to be looked over with a very careful eye imagining extraordinarily bad behavior by shared owners before this contract can be called safe. @@ -159,7 +159,7 @@ Allows owner to set a public string of contract information. No issues. This needs some work. Doesn't check if `_required <= len(_owners)` for instance, that would be a bummer. What if _required were like `MAX - 1`? -I have a general concern about the difference between `owners`, `_owners`, and `owner` in `Ownable.sol`. I recommend "Owners" be renamed. In general we do not recomment single character differences in variable names, although a preceding underscore is not uncommon in Solidity code. +I have a general concern about the difference between `owners`, `_owners`, and `owner` in `Ownable.sol`. I recommend "Owners" be renamed. In general we do not recommend single character differences in variable names, although a preceding underscore is not uncommon in Solidity code. Line 34: "this contract only has six types of events"...actually only two. @@ -224,7 +224,7 @@ Transfer() and transferFrom() use SafeMath functions, which will cause them to t ### SimpleToken -Sample instantiation of StandardToken. Note that in this sample, decimals is 18 and supply only 10,000, so the supply is a small fraction of a single nominal token. +Sample instantiation of StandardToken. Note that in this sample, decimals is 18 and supply is only 10,000, so the supply is a small fraction of a single nominal token. ### CrowdsaleToken diff --git a/audits/2024-12-v5.2.pdf b/audits/2024-12-v5.2.pdf new file mode 100644 index 0000000000000000000000000000000000000000..ef138f7ec61f268020d139c587118e8b476f4cda GIT binary patch literal 242253 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 #Y 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 literal 0 HcmV?d00001 diff --git a/audits/README.md b/audits/README.md index 34bda2af3..4e8c94653 100644 --- a/audits/README.md +++ b/audits/README.md @@ -1,13 +1,14 @@ # Audits -| Date | Version | Commit | Auditor | Scope | Links | -| ------------ | ------- | --------- | ------------ | -------------------- | ----------------------------------------------------------- | -| October 2024 | v5.1.0 | TBD | OpenZeppelin | v5.1 Changes | [🔗](./2024-10-v5.1.pdf) | -| October 2023 | v5.0.0 | `b5a3e69` | OpenZeppelin | v5.0 Changes | [🔗](./2023-10-v5.0.pdf) | -| May 2023 | v4.9.0 | `91df66c` | OpenZeppelin | v4.9 Changes | [🔗](./2023-05-v4.9.pdf) | -| October 2022 | v4.8.0 | `14f98db` | OpenZeppelin | ERC4626, Checkpoints | [🔗](./2022-10-ERC4626.pdf) [🔗](./2022-10-Checkpoints.pdf) | -| October 2018 | v2.0.0 | `dac5bcc` | LevelK | Everything | [🔗](./2018-10.pdf) | -| March 2017 | v1.0.4 | `9c5975a` | New Alchemy | Everything | [🔗](./2017-03.md) | +| Date | Version | Commit | Auditor | Scope | Links | +| ------------- | ------- | -------------------------------------------------------------------------------- | ------------ | -------------------- | ----------------------------------------------------------- | +| December 2024 | v5.2.0 | [`98d28f9`](https://github.com/openzeppelin/openzeppelin-contracts/tree/98d28f9) | OpenZeppelin | v5.2 Changes | [🔗](./2024-12-v5.2.pdf) | +| October 2024 | v5.1.0 | [`aba9ff6`](https://github.com/openzeppelin/openzeppelin-contracts/tree/aba9ff6) | OpenZeppelin | v5.1 Changes | [🔗](./2024-10-v5.1.pdf) | +| October 2023 | v5.0.0 | [`b5a3e69`](https://github.com/openzeppelin/openzeppelin-contracts/tree/b5a3e69) | OpenZeppelin | v5.0 Changes | [🔗](./2023-10-v5.0.pdf) | +| May 2023 | v4.9.0 | [`91df66c`](https://github.com/openzeppelin/openzeppelin-contracts/tree/91df66c) | OpenZeppelin | v4.9 Changes | [🔗](./2023-05-v4.9.pdf) | +| October 2022 | v4.8.0 | [`14f98db`](https://github.com/openzeppelin/openzeppelin-contracts/tree/14f98db) | OpenZeppelin | ERC4626, Checkpoints | [🔗](./2022-10-ERC4626.pdf) [🔗](./2022-10-Checkpoints.pdf) | +| October 2018 | v2.0.0 | [`dac5bcc`](https://github.com/openzeppelin/openzeppelin-contracts/tree/dac5bcc) | LevelK | Everything | [🔗](./2018-10.pdf) | +| March 2017 | v1.0.4 | [`9c5975a`](https://github.com/openzeppelin/openzeppelin-contracts/tree/9c5975a) | New Alchemy | Everything | [🔗](./2017-03.md) | # Formal Verification diff --git a/certora/README.md b/certora/README.md index cd85ba3d4..ff2ccdf7d 100644 --- a/certora/README.md +++ b/certora/README.md @@ -2,14 +2,14 @@ These instructions detail the process for running Certora Verification Tool on OpenZeppelin Contracts. -Documentation for CVT and the specification language are available [here](https://certora.atlassian.net/wiki/spaces/CPD/overview). +Documentation for CVT and the specification language is available [here](https://certora.atlassian.net/wiki/spaces/CPD/overview). ## Prerequisites Follow the [Certora installation guide](https://docs.certora.com/en/latest/docs/user-guide/getting-started/install.html) in order to get the Certora Prover Package and the `solc` executable folder in your path. > **Note** -> An API Key is required for local testing. Although the prover will run on a Github Actions' CI environment on selected Pull Requests. +> An API Key is required for local testing. Although the prover will run on a GitHub Actions' CI environment on selected Pull Requests. ## Running the verification diff --git a/certora/run.js b/certora/run.js index 7b65534ea..91f4a6aec 100755 --- a/certora/run.js +++ b/certora/run.js @@ -7,11 +7,16 @@ // node certora/run.js AccessControl // node certora/run.js AccessControlHarness:AccessControl -const proc = require('child_process'); -const { PassThrough } = require('stream'); -const events = require('events'); +import { spawn } from 'child_process'; +import { PassThrough } from 'stream'; +import { once } from 'events'; +import path from 'path'; +import yargs from 'yargs'; +import { hideBin } from 'yargs/helpers'; +import pLimit from 'p-limit'; +import fs from 'fs/promises'; -const argv = require('yargs') +const argv = yargs(hideBin(process.argv)) .env('') .options({ all: { @@ -21,7 +26,7 @@ const argv = require('yargs') spec: { alias: 's', type: 'string', - default: __dirname + '/specs.json', + default: path.resolve(import.meta.dirname, 'specs.json'), }, parallel: { alias: 'p', @@ -38,18 +43,20 @@ const argv = require('yargs') type: 'array', default: [], }, - }).argv; + }) + .parse(); function match(entry, request) { const [reqSpec, reqContract] = request.split(':').reverse(); return entry.spec == reqSpec && (!reqContract || entry.contract == reqContract); } -const specs = require(argv.spec).filter(s => argv.all || argv._.some(r => match(s, r))); -const limit = require('p-limit')(argv.parallel); +const specs = JSON.parse(fs.readFileSync(argv.spec, 'utf8')).filter(s => argv.all || argv._.some(r => match(s, r))); + +const limit = pLimit(argv.parallel); if (argv._.length == 0 && !argv.all) { - console.error(`Warning: No specs requested. Did you forgot to toggle '--all'?`); + console.error(`Warning: No specs requested. Did you forget to toggle '--all'?`); } for (const r of argv._) { @@ -64,12 +71,13 @@ if (process.exitCode) { } for (const { spec, contract, files, options = [] } of specs) { - limit( - runCertora, - spec, - contract, - files, - [...options, ...argv.options].flatMap(opt => opt.split(' ')), + limit(() => + runCertora( + spec, + contract, + files, + [...options, ...argv.options].flatMap(opt => opt.split(' ')), + ), ); } @@ -79,7 +87,7 @@ async function runCertora(spec, contract, files, options = []) { if (argv.verbose) { console.log('Running:', args.join(' ')); } - const child = proc.spawn('certoraRun', args); + const child = spawn('certoraRun', args); const stream = new PassThrough(); const output = collect(stream); @@ -103,7 +111,7 @@ async function runCertora(spec, contract, files, options = []) { }); // wait for process end - const [code, signal] = await events.once(child, 'exit'); + const [code, signal] = await once(child, 'exit'); // error if (code || signal) { @@ -152,7 +160,7 @@ function writeEntry(spec, contract, success, url) { formatRow( spec, contract, - success ? ':x:' : ':heavy_check_mark:', + success ? ':heavy_check_mark:' : ':x:', url ? `[link](${url?.replace('/output/', '/jobStatus/')})` : 'error', url ? `[link](${url})` : 'error', ), diff --git a/certora/specs/AccessControlDefaultAdminRules.spec b/certora/specs/AccessControlDefaultAdminRules.spec index 2f5bb9d45..5860fd564 100644 --- a/certora/specs/AccessControlDefaultAdminRules.spec +++ b/certora/specs/AccessControlDefaultAdminRules.spec @@ -176,7 +176,7 @@ rule renounceRoleEffect(env e, bytes32 role) { /* ┌─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┐ -│ Rule: defaultAdmin is only affected by accepting an admin transfer or renoucing │ +│ Rule: defaultAdmin is only affected by accepting an admin transfer or renouncing │ └─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┘ */ rule noDefaultAdminChange(env e, method f, calldataarg args) { @@ -188,7 +188,7 @@ rule noDefaultAdminChange(env e, method f, calldataarg args) { f.selector == sig:acceptDefaultAdminTransfer().selector || f.selector == sig:renounceRole(bytes32,address).selector ), - "default admin is only affected by accepting an admin transfer or renoucing"; + "default admin is only affected by accepting an admin transfer or renouncing"; } /* diff --git a/certora/specs/ERC20FlashMint.spec b/certora/specs/ERC20FlashMint.spec index 4071052ea..6942495b0 100644 --- a/certora/specs/ERC20FlashMint.spec +++ b/certora/specs/ERC20FlashMint.spec @@ -18,7 +18,7 @@ methods { */ ghost mapping(address => mathint) trackedMintAmount; ghost mapping(address => mathint) trackedBurnAmount; -ghost mapping(address => mapping(address => mathint)) trackedTransferedAmount; +ghost mapping(address => mapping(address => mathint)) trackedTransferredAmount; function specUpdate(address from, address to, uint256 amount) { if (from == 0 && to == 0) { assert(false); } // defensive @@ -28,7 +28,7 @@ function specUpdate(address from, address to, uint256 amount) { } else if (to == 0) { trackedBurnAmount[from] = amount; } else { - trackedTransferedAmount[from][to] = amount; + trackedTransferredAmount[from][to] = amount; } } @@ -51,5 +51,5 @@ rule checkMintAndBurn(env e) { assert trackedMintAmount[receiver] == to_mathint(amount); assert trackedBurnAmount[receiver] == amount + to_mathint(recipient == 0 ? fees : 0); - assert (fees > 0 && recipient != 0) => trackedTransferedAmount[receiver][recipient] == to_mathint(fees); + assert (fees > 0 && recipient != 0) => trackedTransferredAmount[receiver][recipient] == to_mathint(fees); } diff --git a/contracts/access/AccessControl.sol b/contracts/access/AccessControl.sol index 3e3341e9c..aa6645532 100644 --- a/contracts/access/AccessControl.sol +++ b/contracts/access/AccessControl.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (access/AccessControl.sol) pragma solidity ^0.8.20; @@ -191,7 +191,7 @@ abstract contract AccessControl is Context, IAccessControl, ERC165 { } /** - * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked. + * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked. * * Internal function without access restriction. * diff --git a/contracts/access/IAccessControl.sol b/contracts/access/IAccessControl.sol index 4c16a6ef7..f6dc00d61 100644 --- a/contracts/access/IAccessControl.sol +++ b/contracts/access/IAccessControl.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (access/IAccessControl.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (access/IAccessControl.sol) pragma solidity ^0.8.20; @@ -23,7 +23,7 @@ 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. + * {RoleAdminChanged} not being emitted to signal this. */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); diff --git a/contracts/access/manager/AuthorityUtils.sol b/contracts/access/manager/AuthorityUtils.sol index fb3018ca8..8b0470968 100644 --- a/contracts/access/manager/AuthorityUtils.sol +++ b/contracts/access/manager/AuthorityUtils.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.0) (access/manager/AuthorityUtils.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol) pragma solidity ^0.8.20; @@ -17,16 +17,20 @@ library AuthorityUtils { address target, bytes4 selector ) internal view returns (bool immediate, uint32 delay) { - (bool success, bytes memory data) = authority.staticcall( - abi.encodeCall(IAuthority.canCall, (caller, target, selector)) - ); - if (success) { - if (data.length >= 0x40) { - (immediate, delay) = abi.decode(data, (bool, uint32)); - } else if (data.length >= 0x20) { - immediate = abi.decode(data, (bool)); + bytes memory data = abi.encodeCall(IAuthority.canCall, (caller, target, selector)); + + assembly ("memory-safe") { + mstore(0x00, 0x00) + mstore(0x20, 0x00) + + if staticcall(gas(), authority, add(data, 0x20), mload(data), 0x00, 0x40) { + immediate := mload(0x00) + delay := mload(0x20) + + // If delay does not fit in a uint32, return 0 (no delay) + // equivalent to: if gt(delay, 0xFFFFFFFF) { delay := 0 } + delay := mul(delay, iszero(shr(32, delay))) } } - return (immediate, delay); } } diff --git a/contracts/account/utils/draft-ERC4337Utils.sol b/contracts/account/utils/draft-ERC4337Utils.sol index d13d51939..6d2c8ccca 100644 --- a/contracts/account/utils/draft-ERC4337Utils.sol +++ b/contracts/account/utils/draft-ERC4337Utils.sol @@ -1,12 +1,18 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (account/utils/draft-ERC4337Utils.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (account/utils/draft-ERC4337Utils.sol) pragma solidity ^0.8.20; -import {PackedUserOperation} from "../../interfaces/draft-IERC4337.sol"; +import {IEntryPoint, PackedUserOperation} from "../../interfaces/draft-IERC4337.sol"; import {Math} from "../../utils/math/Math.sol"; +import {Calldata} from "../../utils/Calldata.sol"; import {Packing} from "../../utils/Packing.sol"; +/// @dev This is available on all entrypoint since v0.4.0, but is not formally part of the ERC. +interface IEntryPointExtra { + function getUserOpHash(PackedUserOperation calldata userOp) external view returns (bytes32); +} + /** * @dev Library with common ERC-4337 utility functions. * @@ -15,6 +21,12 @@ import {Packing} from "../../utils/Packing.sol"; library ERC4337Utils { using Packing for *; + /// @dev Address of the entrypoint v0.7.0 + IEntryPoint internal constant ENTRYPOINT_V07 = IEntryPoint(0x0000000071727De22E5E9d8BAf0edAc6f37da032); + + /// @dev Address of the entrypoint v0.8.0 + IEntryPoint internal constant ENTRYPOINT_V08 = IEntryPoint(0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108); + /// @dev For simulation purposes, validateUserOp (and validatePaymasterUserOp) return this value on success. uint256 internal constant SIG_VALIDATION_SUCCESS = 0; @@ -73,31 +85,16 @@ library ERC4337Utils { return (aggregator_, block.timestamp < validAfter || validUntil < block.timestamp); } - /// @dev Computes the hash of a user operation for a given entrypoint and chainid. - function hash( - PackedUserOperation calldata self, - address entrypoint, - uint256 chainid - ) internal pure returns (bytes32) { - bytes32 result = keccak256( - abi.encode( - keccak256( - abi.encode( - self.sender, - self.nonce, - keccak256(self.initCode), - keccak256(self.callData), - self.accountGasLimits, - self.preVerificationGas, - self.gasFees, - keccak256(self.paymasterAndData) - ) - ), - entrypoint, - chainid - ) - ); - return result; + /// @dev Get the hash of a user operation for a given entrypoint + function hash(PackedUserOperation calldata self, address entrypoint) internal view returns (bytes32) { + // NOTE: getUserOpHash is available since v0.4.0 + // + // Prior to v0.8.0, this was easy to replicate for any entrypoint and chainId. Since v0.8.0 of the + // entrypoint, this depends on the Entrypoint's domain separator, which cannot be hardcoded and is complex + // to recompute. Domain separator could be fetch using the `getDomainSeparatorV4` getter, or recomputed from + // the ERC-5267 getter, but both operation would require doing a view call to the entrypoint. Overall it feels + // simpler and less error prone to get that functionality from the entrypoint directly. + return IEntryPointExtra(entrypoint).getUserOpHash(self); } /// @dev Returns `factory` from the {PackedUserOperation}, or address(0) if the initCode is empty or not properly formatted. @@ -107,7 +104,7 @@ library ERC4337Utils { /// @dev Returns `factoryData` from the {PackedUserOperation}, or empty bytes if the initCode is empty or not properly formatted. function factoryData(PackedUserOperation calldata self) internal pure returns (bytes calldata) { - return self.initCode.length < 20 ? _emptyCalldataBytes() : self.initCode[20:]; + return self.initCode.length < 20 ? Calldata.emptyBytes() : self.initCode[20:]; } /// @dev Returns `verificationGasLimit` from the {PackedUserOperation}. @@ -157,14 +154,6 @@ library ERC4337Utils { /// @dev Returns the fourth section of `paymasterAndData` from the {PackedUserOperation}. function paymasterData(PackedUserOperation calldata self) internal pure returns (bytes calldata) { - return self.paymasterAndData.length < 52 ? _emptyCalldataBytes() : self.paymasterAndData[52:]; - } - - // slither-disable-next-line write-after-write - function _emptyCalldataBytes() private pure returns (bytes calldata result) { - assembly ("memory-safe") { - result.offset := 0 - result.length := 0 - } + return self.paymasterAndData.length < 52 ? Calldata.emptyBytes() : self.paymasterAndData[52:]; } } diff --git a/contracts/account/utils/draft-ERC7579Utils.sol b/contracts/account/utils/draft-ERC7579Utils.sol index 28aa64d5c..027d00df4 100644 --- a/contracts/account/utils/draft-ERC7579Utils.sol +++ b/contracts/account/utils/draft-ERC7579Utils.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (account/utils/draft-ERC7579Utils.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (account/utils/draft-ERC7579Utils.sol) pragma solidity ^0.8.20; @@ -218,7 +218,9 @@ library ERC7579Utils { uint256 value, bytes calldata data ) private returns (bytes memory) { - (bool success, bytes memory returndata) = target.call{value: value}(data); + (bool success, bytes memory returndata) = (target == address(0) ? address(this) : target).call{value: value}( + data + ); return _validateExecutionMode(index, execType, success, returndata); } @@ -229,7 +231,7 @@ library ERC7579Utils { address target, bytes calldata data ) private returns (bytes memory) { - (bool success, bytes memory returndata) = target.delegatecall(data); + (bool success, bytes memory returndata) = (target == address(0) ? address(this) : target).delegatecall(data); return _validateExecutionMode(index, execType, success, returndata); } diff --git a/contracts/finance/VestingWallet.sol b/contracts/finance/VestingWallet.sol index d29194563..03024fae7 100644 --- a/contracts/finance/VestingWallet.sol +++ b/contracts/finance/VestingWallet.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (finance/VestingWallet.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (finance/VestingWallet.sol) pragma solidity ^0.8.20; import {IERC20} from "../token/ERC20/IERC20.sol"; @@ -16,7 +16,7 @@ import {Ownable} from "../access/Ownable.sol"; * Consequently, if the vesting has already started, any amount of tokens sent to this contract will (at least partly) * be immediately releasable. * - * By setting the duration to 0, one can configure this contract to behave like an asset timelock that hold tokens for + * By setting the duration to 0, one can configure this contract to behave like an asset timelock that holds tokens for * a beneficiary until a specified time. * * NOTE: Since the wallet is {Ownable}, and ownership can be transferred, it is possible to sell unvested tokens. diff --git a/contracts/governance/Governor.sol b/contracts/governance/Governor.sol index 41258afff..c0f7a8b48 100644 --- a/contracts/governance/Governor.sol +++ b/contracts/governance/Governor.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (governance/Governor.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/Governor.sol) pragma solidity ^0.8.20; @@ -21,9 +21,9 @@ import {IGovernor, IERC6372} from "./IGovernor.sol"; * * This contract is abstract and requires several functions to be implemented in various modules: * - * - A counting module must implement {quorum}, {_quorumReached}, {_voteSucceeded} and {_countVote} + * - A counting module must implement {_quorumReached}, {_voteSucceeded} and {_countVote} * - A voting module must implement {_getVotes} - * - Additionally, {votingPeriod} must also be implemented + * - Additionally, {votingPeriod}, {votingDelay}, and {quorum} must also be implemented */ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC721Receiver, IERC1155Receiver { using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque; @@ -92,6 +92,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return interfaceId == type(IGovernor).interfaceId || + interfaceId == type(IGovernor).interfaceId ^ IGovernor.getProposalId.selector || interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId); } @@ -132,6 +133,18 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 return uint256(keccak256(abi.encode(targets, values, calldatas, descriptionHash))); } + /** + * @dev See {IGovernor-getProposalId}. + */ + function getProposalId( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash + ) public view virtual returns (uint256) { + return hashProposal(targets, values, calldatas, descriptionHash); + } + /** * @dev See {IGovernor-state}. */ @@ -317,7 +330,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 string memory description, address proposer ) internal virtual returns (uint256 proposalId) { - proposalId = hashProposal(targets, values, calldatas, keccak256(bytes(description))); + proposalId = getProposalId(targets, values, calldatas, keccak256(bytes(description))); if (targets.length != values.length || targets.length != calldatas.length || targets.length == 0) { revert GovernorInvalidProposalLength(targets.length, calldatas.length, values.length); @@ -358,7 +371,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 bytes[] memory calldatas, bytes32 descriptionHash ) public virtual returns (uint256) { - uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash); + uint256 proposalId = getProposalId(targets, values, calldatas, descriptionHash); _validateStateBitmap(proposalId, _encodeStateBitmap(ProposalState.Succeeded)); @@ -406,7 +419,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 bytes[] memory calldatas, bytes32 descriptionHash ) public payable virtual returns (uint256) { - uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash); + uint256 proposalId = getProposalId(targets, values, calldatas, descriptionHash); _validateStateBitmap( proposalId, @@ -442,7 +455,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 * performed (for example adding a vault/timelock). * * NOTE: Calling this function directly will NOT check the current state of the proposal, set the executed flag to - * true or emit the `ProposalExecuted` event. Executing a proposal should be done using {execute} or {_execute}. + * true or emit the `ProposalExecuted` event. Executing a proposal should be done using {execute}. */ function _executeOperations( uint256 /* proposalId */, @@ -468,14 +481,11 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 ) public virtual returns (uint256) { // The proposalId will be recomputed in the `_cancel` call further down. However we need the value before we // do the internal call, because we need to check the proposal state BEFORE the internal `_cancel` call - // changes it. The `hashProposal` duplication has a cost that is limited, and that we accept. - uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash); + // changes it. The `getProposalId` duplication has a cost that is limited, and that we accept. + uint256 proposalId = getProposalId(targets, values, calldatas, descriptionHash); - // public cancel restrictions (on top of existing _cancel restrictions). - _validateStateBitmap(proposalId, _encodeStateBitmap(ProposalState.Pending)); - if (_msgSender() != proposalProposer(proposalId)) { - revert GovernorOnlyProposer(_msgSender()); - } + address caller = _msgSender(); + if (!_validateCancel(proposalId, caller)) revert GovernorUnableToCancel(proposalId, caller); return _cancel(targets, values, calldatas, descriptionHash); } @@ -492,7 +502,7 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 bytes[] memory calldatas, bytes32 descriptionHash ) internal virtual returns (uint256) { - uint256 proposalId = hashProposal(targets, values, calldatas, descriptionHash); + uint256 proposalId = getProposalId(targets, values, calldatas, descriptionHash); _validateStateBitmap( proposalId, @@ -792,6 +802,15 @@ abstract contract Governor is Context, ERC165, EIP712, Nonces, IGovernor, IERC72 } } + /** + * @dev Check if the `caller` can cancel the proposal with the given `proposalId`. + * + * The default implementation allows the proposal proposer to cancel the proposal during the pending state. + */ + function _validateCancel(uint256 proposalId, address caller) internal view virtual returns (bool) { + return (state(proposalId) == ProposalState.Pending) && caller == proposalProposer(proposalId); + } + /** * @inheritdoc IERC6372 */ diff --git a/contracts/governance/IGovernor.sol b/contracts/governance/IGovernor.sol index 28f8aaac0..d51e7deb2 100644 --- a/contracts/governance/IGovernor.sol +++ b/contracts/governance/IGovernor.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (governance/IGovernor.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/IGovernor.sol) pragma solidity ^0.8.20; @@ -39,11 +39,6 @@ interface IGovernor is IERC165, IERC6372 { */ error GovernorDisabledDeposit(); - /** - * @dev The `account` is not a proposer. - */ - error GovernorOnlyProposer(address account); - /** * @dev The `account` is not the governance executor. */ @@ -112,6 +107,11 @@ interface IGovernor is IERC165, IERC6372 { */ error GovernorInvalidSignature(address voter); + /** + * @dev The given `account` is unable to cancel the proposal with given `proposalId`. + */ + error GovernorUnableToCancel(uint256 proposalId, address account); + /** * @dev Emitted when a proposal is created. */ @@ -203,7 +203,9 @@ interface IGovernor is IERC165, IERC6372 { /** * @notice module:core - * @dev Hashing function used to (re)build the proposal id from the proposal details.. + * @dev Hashing function used to (re)build the proposal id from the proposal details. + * + * NOTE: For all off-chain and external calls, use {getProposalId}. */ function hashProposal( address[] memory targets, @@ -212,6 +214,17 @@ interface IGovernor is IERC165, IERC6372 { bytes32 descriptionHash ) external pure returns (uint256); + /** + * @notice module:core + * @dev Function used to get the proposal id from the proposal details. + */ + function getProposalId( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash + ) external view returns (uint256); + /** * @notice module:core * @dev Current state of a proposal, following Compound's convention diff --git a/contracts/governance/README.adoc b/contracts/governance/README.adoc index d390d1be8..0a9c2c4e3 100644 --- a/contracts/governance/README.adoc +++ b/contracts/governance/README.adoc @@ -20,17 +20,19 @@ For a written walkthrough, check out our guide on xref:ROOT:governance.adoc[How Votes modules determine the source of voting power, and sometimes quorum number. -* {GovernorVotes}: Extracts voting weight from an {ERC20Votes}, or since v4.5 an {ERC721Votes} token. +* {GovernorVotes}: Extracts voting weight from an {IVotes} contract. * {GovernorVotesQuorumFraction}: Combines with `GovernorVotes` to set the quorum as a fraction of the total token supply. +* {GovernorVotesSuperQuorumFraction}: Combines `GovernorSuperQuorum` with `GovernorVotesQuorumFraction` to set the super quorum as a fraction of the total token supply. + Counting modules determine valid voting options. * {GovernorCountingSimple}: Simple voting mechanism with 3 voting options: Against, For and Abstain. * {GovernorCountingFractional}: A more modular voting system that allows a user to vote with only part of its voting power, and to split that weight arbitrarily between the 3 different options (Against, For and Abstain). -* {GovernorCountingOverridable}: An extended version of `GovernorCountingSimple` which allows delegatees to override their delegates while the vote is live. +* {GovernorCountingOverridable}: An extended version of `GovernorCountingSimple` which allows delegatees to override their delegates while the vote is live. Must be used in conjunction with {VotesExtended}. Timelock extensions add a delay for governance decisions to be executed. The workflow is extended to require a `queue` step before execution. With these modules, proposals are executed by the external timelock contract, thus it is the timelock that has to hold the assets that are being governed. @@ -48,6 +50,10 @@ Other extensions can customize the behavior or interface in multiple ways. * {GovernorPreventLateQuorum}: Ensures there is a minimum voting period after quorum is reached as a security protection against large voters. +* {GovernorProposalGuardian}: Adds a proposal guardian that can cancel proposals at any stage in their lifecycle--this permission is passed on to the proposers if the guardian is not set. + +* {GovernorSuperQuorum}: Extension of {Governor} with a super quorum. Proposals that meet the super quorum (and have a majority of for votes) advance to the `Succeeded` state before the proposal deadline. + In addition to modules and extensions, the core contract requires a few virtual functions to be implemented to your particular specifications: * <>: Delay (in ERC-6372 clock) since the proposal is submitted until voting power is fixed and voting starts. This can be used to enforce a delay after a proposal is published for users to buy tokens, or delegate their votes. @@ -68,12 +74,14 @@ NOTE: Functions of the `Governor` contract do not include access control. If you {{GovernorCountingFractional}} -{{GovernorCountingOverride}} +{{GovernorCountingOverridable}} {{GovernorVotes}} {{GovernorVotesQuorumFraction}} +{{GovernorVotesSuperQuorumFraction}} + === Extensions {{GovernorTimelockAccess}} @@ -88,6 +96,10 @@ NOTE: Functions of the `Governor` contract do not include access control. If you {{GovernorStorage}} +{{GovernorProposalGuardian}} + +{{GovernorSuperQuorum}} + == Utils {{Votes}} @@ -103,7 +115,7 @@ In a governance system, the {TimelockController} contract is in charge of introd [[timelock-terminology]] ==== Terminology -* *Operation:* A transaction (or a set of transactions) that is the subject of the timelock. It has to be scheduled by a proposer and executed by an executor. The timelock enforces a minimum delay between the proposition and the execution (see xref:access-control.adoc#operation_lifecycle[operation lifecycle]). If the operation contains multiple transactions (batch mode), they are executed atomically. Operations are identified by the hash of their content. +* *Operation:* A transaction (or a set of transactions) that is the subject of the timelock. It has to be scheduled by a proposer and executed by an executor. The timelock enforces a minimum delay between the proposition and the execution. If the operation contains multiple transactions (batch mode), they are executed atomically. Operations are identified by the hash of their content. * *Operation status:* ** *Unset:* An operation that is not part of the timelock mechanism. ** *Waiting:* An operation that has been scheduled, before the timer expires. diff --git a/contracts/governance/TimelockController.sol b/contracts/governance/TimelockController.sol index 349d940fd..b8e4bfae6 100644 --- a/contracts/governance/TimelockController.sol +++ b/contracts/governance/TimelockController.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.0) (governance/TimelockController.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/TimelockController.sol) pragma solidity ^0.8.20; @@ -152,7 +152,7 @@ contract TimelockController is AccessControl, ERC721Holder, ERC1155Holder { /** * @dev Contract might receive/hold ETH as part of the maintenance process. */ - receive() external payable {} + receive() external payable virtual {} /** * @dev See {IERC165-supportsInterface}. diff --git a/contracts/governance/extensions/GovernorCountingFractional.sol b/contracts/governance/extensions/GovernorCountingFractional.sol index d2231bb95..2462227a0 100644 --- a/contracts/governance/extensions/GovernorCountingFractional.sol +++ b/contracts/governance/extensions/GovernorCountingFractional.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (governance/extensions/GovernorCountingFractional.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorCountingFractional.sol) pragma solidity ^0.8.20; @@ -27,7 +27,7 @@ import {Math} from "../../utils/math/Math.sol"; * * Voting from an L2 with tokens held by a bridge * * Voting privately from a shielded pool using zero knowledge proofs. * - * Based on ScopeLift's GovernorCountingFractional[https://github.com/ScopeLift/flexible-voting/blob/e5de2efd1368387b840931f19f3c184c85842761/src/GovernorCountingFractional.sol] + * Based on ScopeLift's https://github.com/ScopeLift/flexible-voting/blob/e5de2efd1368387b840931f19f3c184c85842761/src/GovernorCountingFractional.sol[`GovernorCountingFractional`] * * _Available since v5.1._ */ @@ -125,9 +125,9 @@ abstract contract GovernorCountingFractional is Governor { * * `abi.encodePacked(uint128(againstVotes), uint128(forVotes), uint128(abstainVotes))` * - * NOTE: Consider that fractional voting restricts the number of casted vote (in each category) to 128 bits. + * NOTE: Consider that fractional voting restricts the number of casted votes (in each category) to 128 bits. * Depending on how many decimals the underlying token has, a single voter may require to split their vote into - * multiple vote operations. For precision higher than ~30 decimals, large token holders may require an + * multiple vote operations. For precision higher than ~30 decimals, large token holders may require a * potentially large number of calls to cast all their votes. The voter has the possibility to cast all the * remaining votes in a single operation using the traditional "bravo" vote. */ diff --git a/contracts/governance/extensions/GovernorCountingOverridable.sol b/contracts/governance/extensions/GovernorCountingOverridable.sol index 2ed6c1cc5..bc06de96d 100644 --- a/contracts/governance/extensions/GovernorCountingOverridable.sol +++ b/contracts/governance/extensions/GovernorCountingOverridable.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (governance/extensions/GovernorCountingOverridable.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorCountingOverridable.sol) pragma solidity ^0.8.20; @@ -27,8 +27,8 @@ abstract contract GovernorCountingOverridable is GovernorVotes { struct VoteReceipt { uint8 casted; // 0 if vote was not casted. Otherwise: support + 1 - bool hasOverriden; - uint208 overridenWeight; + bool hasOverridden; + uint208 overriddenWeight; } struct ProposalVote { @@ -42,7 +42,7 @@ abstract contract GovernorCountingOverridable is GovernorVotes { /// @dev A delegated vote on `proposalId` was overridden by `weight` event OverrideVoteCast(address indexed voter, uint256 proposalId, uint8 support, uint256 weight, string reason); - error GovernorAlreadyOverridenVote(address account); + error GovernorAlreadyOverriddenVote(address account); mapping(uint256 proposalId => ProposalVote) private _proposalVotes; @@ -70,7 +70,7 @@ abstract contract GovernorCountingOverridable is GovernorVotes { * @dev Check if an `account` has overridden their delegate for a proposal. */ function hasVotedOverride(uint256 proposalId, address account) public view virtual returns (bool) { - return _proposalVotes[proposalId].voteReceipt[account].hasOverriden; + return _proposalVotes[proposalId].voteReceipt[account].hasOverridden; } /** @@ -122,7 +122,7 @@ abstract contract GovernorCountingOverridable is GovernorVotes { revert GovernorAlreadyCastVote(account); } - totalWeight -= proposalVote.voteReceipt[account].overridenWeight; + totalWeight -= proposalVote.voteReceipt[account].overriddenWeight; proposalVote.votes[support] += totalWeight; proposalVote.voteReceipt[account].casted = support + 1; @@ -141,26 +141,26 @@ abstract contract GovernorCountingOverridable is GovernorVotes { revert GovernorInvalidVoteType(); } - if (proposalVote.voteReceipt[account].hasOverriden) { - revert GovernorAlreadyOverridenVote(account); + if (proposalVote.voteReceipt[account].hasOverridden) { + revert GovernorAlreadyOverriddenVote(account); } uint256 snapshot = proposalSnapshot(proposalId); - uint256 overridenWeight = VotesExtended(address(token())).getPastBalanceOf(account, snapshot); + uint256 overriddenWeight = VotesExtended(address(token())).getPastBalanceOf(account, snapshot); address delegate = VotesExtended(address(token())).getPastDelegate(account, snapshot); uint8 delegateCasted = proposalVote.voteReceipt[delegate].casted; - proposalVote.voteReceipt[account].hasOverriden = true; - proposalVote.votes[support] += overridenWeight; + proposalVote.voteReceipt[account].hasOverridden = true; + proposalVote.votes[support] += overriddenWeight; if (delegateCasted == 0) { - proposalVote.voteReceipt[delegate].overridenWeight += SafeCast.toUint208(overridenWeight); + proposalVote.voteReceipt[delegate].overriddenWeight += SafeCast.toUint208(overriddenWeight); } else { uint8 delegateSupport = delegateCasted - 1; - proposalVote.votes[delegateSupport] -= overridenWeight; - emit VoteReduced(delegate, proposalId, delegateSupport, overridenWeight); + proposalVote.votes[delegateSupport] -= overriddenWeight; + emit VoteReduced(delegate, proposalId, delegateSupport, overriddenWeight); } - return overridenWeight; + return overriddenWeight; } /// @dev Variant of {Governor-_castVote} that deals with vote overrides. Returns the overridden weight. @@ -172,13 +172,13 @@ abstract contract GovernorCountingOverridable is GovernorVotes { ) internal virtual returns (uint256) { _validateStateBitmap(proposalId, _encodeStateBitmap(ProposalState.Active)); - uint256 overridenWeight = _countOverride(proposalId, account, support); + uint256 overriddenWeight = _countOverride(proposalId, account, support); - emit OverrideVoteCast(account, proposalId, support, overridenWeight, reason); + emit OverrideVoteCast(account, proposalId, support, overriddenWeight, reason); _tallyUpdated(proposalId); - return overridenWeight; + return overriddenWeight; } /// @dev Public function for casting an override vote. Returns the overridden weight. diff --git a/contracts/governance/extensions/GovernorProposalGuardian.sol b/contracts/governance/extensions/GovernorProposalGuardian.sol new file mode 100644 index 000000000..10821ff41 --- /dev/null +++ b/contracts/governance/extensions/GovernorProposalGuardian.sol @@ -0,0 +1,58 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorProposalGuardian.sol) +pragma solidity ^0.8.20; + +import {Governor} from "../Governor.sol"; + +/** + * @dev Extension of {Governor} which adds a proposal guardian that can cancel proposals at any stage in the proposal's lifecycle. + * + * NOTE: if the proposal guardian is not configured, then proposers take this role for their proposals. + */ +abstract contract GovernorProposalGuardian is Governor { + address private _proposalGuardian; + + event ProposalGuardianSet(address oldProposalGuardian, address newProposalGuardian); + + /** + * @dev Getter that returns the address of the proposal guardian. + */ + function proposalGuardian() public view virtual returns (address) { + return _proposalGuardian; + } + + /** + * @dev Update the proposal guardian's address. This operation can only be performed through a governance proposal. + * + * Emits a {ProposalGuardianSet} event. + */ + function setProposalGuardian(address newProposalGuardian) public virtual onlyGovernance { + _setProposalGuardian(newProposalGuardian); + } + + /** + * @dev Internal setter for the proposal guardian. + * + * Emits a {ProposalGuardianSet} event. + */ + function _setProposalGuardian(address newProposalGuardian) internal virtual { + emit ProposalGuardianSet(_proposalGuardian, newProposalGuardian); + _proposalGuardian = newProposalGuardian; + } + + /** + * @dev Override {Governor-_validateCancel} to implement the extended cancellation logic. + * + * * The {proposalGuardian} can cancel any proposal at any point. + * * If no proposal guardian is set, the {IGovernor-proposalProposer} can cancel their proposals at any point. + * * In any case, permissions defined in {Governor-_validateCancel} (or another override) remains valid. + */ + function _validateCancel(uint256 proposalId, address caller) internal view virtual override returns (bool) { + address guardian = proposalGuardian(); + + return + guardian == caller || + (guardian == address(0) && caller == proposalProposer(proposalId)) || + super._validateCancel(proposalId, caller); + } +} diff --git a/contracts/governance/extensions/GovernorSequentialProposalId.sol b/contracts/governance/extensions/GovernorSequentialProposalId.sol new file mode 100644 index 000000000..8cfa5aa46 --- /dev/null +++ b/contracts/governance/extensions/GovernorSequentialProposalId.sol @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorSequentialProposalId.sol) + +pragma solidity ^0.8.20; + +import {Governor} from "../Governor.sol"; + +/** + * @dev Extension of {Governor} that changes the numbering of proposal ids from the default hash-based approach to + * sequential ids. + */ +abstract contract GovernorSequentialProposalId is Governor { + uint256 private _latestProposalId; + mapping(uint256 proposalHash => uint256 proposalId) private _proposalIds; + + /** + * @dev The {latestProposalId} may only be initialized if it hasn't been set yet + * (through initialization or the creation of a proposal). + */ + error GovernorAlreadyInitializedLatestProposalId(); + + /** + * @dev See {IGovernor-getProposalId}. + */ + function getProposalId( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash + ) public view virtual override returns (uint256) { + uint256 proposalHash = hashProposal(targets, values, calldatas, descriptionHash); + uint256 storedProposalId = _proposalIds[proposalHash]; + if (storedProposalId == 0) { + revert GovernorNonexistentProposal(0); + } + return storedProposalId; + } + + /** + * @dev Returns the latest proposal id. A return value of 0 means no proposals have been created yet. + */ + function latestProposalId() public view virtual returns (uint256) { + return _latestProposalId; + } + + /** + * @dev See {IGovernor-_propose}. + * Hook into the proposing mechanism to increment proposal count. + */ + function _propose( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + string memory description, + address proposer + ) internal virtual override returns (uint256) { + uint256 proposalHash = hashProposal(targets, values, calldatas, keccak256(bytes(description))); + uint256 storedProposalId = _proposalIds[proposalHash]; + if (storedProposalId == 0) { + _proposalIds[proposalHash] = ++_latestProposalId; + } + return super._propose(targets, values, calldatas, description, proposer); + } + + /** + * @dev Internal function to set the {latestProposalId}. This function is helpful when transitioning + * from another governance system. The next proposal id will be `newLatestProposalId` + 1. + * + * May only call this function if the current value of {latestProposalId} is 0. + */ + function _initializeLatestProposalId(uint256 newLatestProposalId) internal virtual { + if (_latestProposalId != 0) { + revert GovernorAlreadyInitializedLatestProposalId(); + } + _latestProposalId = newLatestProposalId; + } +} diff --git a/contracts/governance/extensions/GovernorStorage.sol b/contracts/governance/extensions/GovernorStorage.sol index 22db09992..914b77d9d 100644 --- a/contracts/governance/extensions/GovernorStorage.sol +++ b/contracts/governance/extensions/GovernorStorage.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (governance/extensions/GovernorStorage.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorStorage.sol) pragma solidity ^0.8.20; @@ -50,7 +50,7 @@ abstract contract GovernorStorage is Governor { } /** - * @dev Version of {IGovernorTimelock-queue} with only `proposalId` as an argument. + * @dev Version of {IGovernor-queue} with only `proposalId` as an argument. */ function queue(uint256 proposalId) public virtual { // here, using storage is more efficient than memory diff --git a/contracts/governance/extensions/GovernorSuperQuorum.sol b/contracts/governance/extensions/GovernorSuperQuorum.sol new file mode 100644 index 000000000..f10e8e13f --- /dev/null +++ b/contracts/governance/extensions/GovernorSuperQuorum.sol @@ -0,0 +1,60 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorSuperQuorum.sol) +pragma solidity ^0.8.20; + +import {Governor} from "../Governor.sol"; +import {SafeCast} from "../../utils/math/SafeCast.sol"; +import {Checkpoints} from "../../utils/structs/Checkpoints.sol"; + +/** + * @dev Extension of {Governor} with a super quorum. Proposals that meet the super quorum (and have a majority of for + * votes) advance to the `Succeeded` state before the proposal deadline. Counting modules that want to use this + * extension must implement {proposalVotes}. + */ +abstract contract GovernorSuperQuorum is Governor { + /** + * @dev Minimum number of cast votes required for a proposal to reach super quorum. Only FOR votes are counted + * towards the super quorum. Once the super quorum is reached, an active proposal can proceed to the next state + * without waiting for the proposal deadline. + * + * NOTE: The `timepoint` parameter corresponds to the snapshot used for counting the vote. This enables scaling of the + * quorum depending on values such as the `totalSupply` of a token at this timepoint (see {ERC20Votes}). + * + * NOTE: Make sure the value specified for the super quorum is greater than {quorum}, otherwise, it may be + * possible to pass a proposal with less votes than the default quorum. + */ + function superQuorum(uint256 timepoint) public view virtual returns (uint256); + + /** + * @dev Accessor to the internal vote counts. This must be implemented by the counting module. Counting modules + * that don't implement this function are incompatible with this module + */ + function proposalVotes( + uint256 proposalId + ) public view virtual returns (uint256 againstVotes, uint256 forVotes, uint256 abstainVotes); + + /** + * @dev Overridden version of the {Governor-state} function that checks if the proposal has reached the super + * quorum. + * + * NOTE: If the proposal reaches super quorum but {_voteSucceeded} returns false, eg, assuming the super quorum + * has been set low enough that both FOR and AGAINST votes have exceeded it and AGAINST votes exceed FOR votes, + * the proposal continues to be active until {_voteSucceeded} returns true or the proposal deadline is reached. + * This means that with a low super quorum it is also possible that a vote can succeed prematurely before enough + * AGAINST voters have a chance to vote. Hence, it is recommended to set a high enough super quorum to avoid these + * types of scenarios. + */ + function state(uint256 proposalId) public view virtual override returns (ProposalState) { + ProposalState currentState = super.state(proposalId); + if (currentState != ProposalState.Active) return currentState; + + (, uint256 forVotes, ) = proposalVotes(proposalId); + if (forVotes < superQuorum(proposalSnapshot(proposalId)) || !_voteSucceeded(proposalId)) { + return ProposalState.Active; + } else if (proposalEta(proposalId) == 0) { + return ProposalState.Succeeded; + } else { + return ProposalState.Queued; + } + } +} diff --git a/contracts/governance/extensions/GovernorTimelockAccess.sol b/contracts/governance/extensions/GovernorTimelockAccess.sol index 5b8429b83..c208c5a36 100644 --- a/contracts/governance/extensions/GovernorTimelockAccess.sol +++ b/contracts/governance/extensions/GovernorTimelockAccess.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (governance/extensions/GovernorTimelockAccess.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorTimelockAccess.sol) pragma solidity ^0.8.20; @@ -277,7 +277,7 @@ abstract contract GovernorTimelockAccess is Governor { } /** - * @dev See {IGovernor-_cancel} + * @dev See {Governor-_cancel} */ function _cancel( address[] memory targets, diff --git a/contracts/governance/extensions/GovernorTimelockCompound.sol b/contracts/governance/extensions/GovernorTimelockCompound.sol index 309f9a4fa..e0f4f5571 100644 --- a/contracts/governance/extensions/GovernorTimelockCompound.sol +++ b/contracts/governance/extensions/GovernorTimelockCompound.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (governance/extensions/GovernorTimelockCompound.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorTimelockCompound.sol) pragma solidity ^0.8.20; @@ -10,7 +10,7 @@ import {SafeCast} from "../../utils/math/SafeCast.sol"; /** * @dev Extension of {Governor} that binds the execution process to a Compound Timelock. This adds a delay, enforced by - * the external timelock to all successful proposal (in addition to the voting duration). The {Governor} needs to be + * the external timelock to all successful proposals (in addition to the voting duration). The {Governor} needs to be * the admin of the timelock for any operation to be performed. A public, unrestricted, * {GovernorTimelockCompound-__acceptAdmin} is available to accept ownership of the timelock. * diff --git a/contracts/governance/extensions/GovernorTimelockControl.sol b/contracts/governance/extensions/GovernorTimelockControl.sol index ba0953d16..02262cef7 100644 --- a/contracts/governance/extensions/GovernorTimelockControl.sol +++ b/contracts/governance/extensions/GovernorTimelockControl.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (governance/extensions/GovernorTimelockControl.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorTimelockControl.sol) pragma solidity ^0.8.20; @@ -17,7 +17,7 @@ import {SafeCast} from "../../utils/math/SafeCast.sol"; * the assets and permissions must be attached to the {TimelockController}. Any asset sent to the {Governor} will be * inaccessible from a proposal, unless executed via {Governor-relay}. * - * WARNING: Setting up the TimelockController to have additional proposers or cancellers besides the governor is very + * WARNING: Setting up the TimelockController to have additional proposers or cancelers besides the governor is very * risky, as it grants them the ability to: 1) execute operations as the timelock, and thus possibly performing * operations or accessing funds that are expected to only be accessible through a vote, and 2) block governance * proposals that have been approved by the voters, effectively executing a Denial of Service attack. diff --git a/contracts/governance/extensions/GovernorVotesQuorumFraction.sol b/contracts/governance/extensions/GovernorVotesQuorumFraction.sol index 85a1f9826..a72d9de2a 100644 --- a/contracts/governance/extensions/GovernorVotesQuorumFraction.sol +++ b/contracts/governance/extensions/GovernorVotesQuorumFraction.sol @@ -1,9 +1,10 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.0) (governance/extensions/GovernorVotesQuorumFraction.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorVotesQuorumFraction.sol) pragma solidity ^0.8.20; import {GovernorVotes} from "./GovernorVotes.sol"; +import {Math} from "../../utils/math/Math.sol"; import {SafeCast} from "../../utils/math/SafeCast.sol"; import {Checkpoints} from "../../utils/structs/Checkpoints.sol"; @@ -45,18 +46,7 @@ abstract contract GovernorVotesQuorumFraction is GovernorVotes { * @dev Returns the quorum numerator at a specific timepoint. See {quorumDenominator}. */ function quorumNumerator(uint256 timepoint) public view virtual returns (uint256) { - uint256 length = _quorumNumeratorHistory._checkpoints.length; - - // Optimistic search, check the latest checkpoint - Checkpoints.Checkpoint208 storage latest = _quorumNumeratorHistory._checkpoints[length - 1]; - uint48 latestKey = latest._key; - uint208 latestValue = latest._value; - if (latestKey <= timepoint) { - return latestValue; - } - - // Otherwise, do the binary search - return _quorumNumeratorHistory.upperLookupRecent(SafeCast.toUint48(timepoint)); + return _optimisticUpperLookupRecent(_quorumNumeratorHistory, timepoint); } /** @@ -70,7 +60,7 @@ abstract contract GovernorVotesQuorumFraction is GovernorVotes { * @dev Returns the quorum for a timepoint, in terms of number of votes: `supply * numerator / denominator`. */ function quorum(uint256 timepoint) public view virtual override returns (uint256) { - return (token().getPastTotalSupply(timepoint) * quorumNumerator(timepoint)) / quorumDenominator(); + return Math.mulDiv(token().getPastTotalSupply(timepoint), quorumNumerator(timepoint), quorumDenominator()); } /** @@ -107,4 +97,17 @@ abstract contract GovernorVotesQuorumFraction is GovernorVotes { emit QuorumNumeratorUpdated(oldQuorumNumerator, newQuorumNumerator); } + + /** + * @dev Returns the numerator at a specific timepoint. + */ + function _optimisticUpperLookupRecent( + Checkpoints.Trace208 storage ckpts, + uint256 timepoint + ) internal view returns (uint256) { + // If trace is empty, key and value are both equal to 0. + // In that case `key <= timepoint` is true, and it is ok to return 0. + (, uint48 key, uint208 value) = ckpts.latestCheckpoint(); + return key <= timepoint ? value : ckpts.upperLookupRecent(SafeCast.toUint48(timepoint)); + } } diff --git a/contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol b/contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol new file mode 100644 index 000000000..6686210e5 --- /dev/null +++ b/contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol @@ -0,0 +1,134 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (governance/extensions/GovernorVotesSuperQuorumFraction.sol) +pragma solidity ^0.8.20; + +import {Governor} from "../Governor.sol"; +import {GovernorSuperQuorum} from "./GovernorSuperQuorum.sol"; +import {GovernorVotesQuorumFraction} from "./GovernorVotesQuorumFraction.sol"; +import {Math} from "../../utils/math/Math.sol"; +import {SafeCast} from "../../utils/math/SafeCast.sol"; +import {Checkpoints} from "../../utils/structs/Checkpoints.sol"; + +/** + * @dev Extension of {GovernorVotesQuorumFraction} with a super quorum expressed as a + * fraction of the total supply. Proposals that meet the super quorum (and have a majority of for votes) advance to + * the `Succeeded` state before the proposal deadline. + */ +abstract contract GovernorVotesSuperQuorumFraction is GovernorVotesQuorumFraction, GovernorSuperQuorum { + using Checkpoints for Checkpoints.Trace208; + + Checkpoints.Trace208 private _superQuorumNumeratorHistory; + + event SuperQuorumNumeratorUpdated(uint256 oldSuperQuorumNumerator, uint256 newSuperQuorumNumerator); + + /** + * @dev The super quorum set is not valid as it exceeds the quorum denominator. + */ + error GovernorInvalidSuperQuorumFraction(uint256 superQuorumNumerator, uint256 denominator); + + /** + * @dev The super quorum set is not valid as it is smaller or equal to the quorum. + */ + error GovernorInvalidSuperQuorumTooSmall(uint256 superQuorumNumerator, uint256 quorumNumerator); + + /** + * @dev The quorum set is not valid as it exceeds the super quorum. + */ + error GovernorInvalidQuorumTooLarge(uint256 quorumNumerator, uint256 superQuorumNumerator); + + /** + * @dev Initialize super quorum as a fraction of the token's total supply. + * + * The super quorum is specified as a fraction of the token's total supply and has to + * be greater than the quorum. + */ + constructor(uint256 superQuorumNumeratorValue) { + _updateSuperQuorumNumerator(superQuorumNumeratorValue); + } + + /** + * @dev Returns the current super quorum numerator. + */ + function superQuorumNumerator() public view virtual returns (uint256) { + return _superQuorumNumeratorHistory.latest(); + } + + /** + * @dev Returns the super quorum numerator at a specific `timepoint`. + */ + function superQuorumNumerator(uint256 timepoint) public view virtual returns (uint256) { + return _optimisticUpperLookupRecent(_superQuorumNumeratorHistory, timepoint); + } + + /** + * @dev Returns the super quorum for a `timepoint`, in terms of number of votes: `supply * numerator / denominator`. + * See {GovernorSuperQuorum-superQuorum} for more details. + */ + function superQuorum(uint256 timepoint) public view virtual override returns (uint256) { + return Math.mulDiv(token().getPastTotalSupply(timepoint), superQuorumNumerator(timepoint), quorumDenominator()); + } + + /** + * @dev Changes the super quorum numerator. + * + * Emits a {SuperQuorumNumeratorUpdated} event. + * + * Requirements: + * + * - Must be called through a governance proposal. + * - New super quorum numerator must be smaller or equal to the denominator. + * - New super quorum numerator must be greater than or equal to the quorum numerator. + */ + function updateSuperQuorumNumerator(uint256 newSuperQuorumNumerator) public virtual onlyGovernance { + _updateSuperQuorumNumerator(newSuperQuorumNumerator); + } + + /** + * @dev Changes the super quorum numerator. + * + * Emits a {SuperQuorumNumeratorUpdated} event. + * + * Requirements: + * + * - New super quorum numerator must be smaller or equal to the denominator. + * - New super quorum numerator must be greater than or equal to the quorum numerator. + */ + function _updateSuperQuorumNumerator(uint256 newSuperQuorumNumerator) internal virtual { + uint256 denominator = quorumDenominator(); + if (newSuperQuorumNumerator > denominator) { + revert GovernorInvalidSuperQuorumFraction(newSuperQuorumNumerator, denominator); + } + + uint256 quorumNumerator = quorumNumerator(); + if (newSuperQuorumNumerator < quorumNumerator) { + revert GovernorInvalidSuperQuorumTooSmall(newSuperQuorumNumerator, quorumNumerator); + } + + uint256 oldSuperQuorumNumerator = _superQuorumNumeratorHistory.latest(); + _superQuorumNumeratorHistory.push(clock(), SafeCast.toUint208(newSuperQuorumNumerator)); + + emit SuperQuorumNumeratorUpdated(oldSuperQuorumNumerator, newSuperQuorumNumerator); + } + + /** + * @dev Overrides {GovernorVotesQuorumFraction-_updateQuorumNumerator} to ensure the super + * quorum numerator is greater than or equal to the quorum numerator. + */ + function _updateQuorumNumerator(uint256 newQuorumNumerator) internal virtual override { + // Ignoring check when the superQuorum was never set (construction sets quorum before superQuorum) + if (_superQuorumNumeratorHistory.length() > 0) { + uint256 superQuorumNumerator_ = superQuorumNumerator(); + if (newQuorumNumerator > superQuorumNumerator_) { + revert GovernorInvalidQuorumTooLarge(newQuorumNumerator, superQuorumNumerator_); + } + } + super._updateQuorumNumerator(newQuorumNumerator); + } + + /// @inheritdoc GovernorSuperQuorum + function state( + uint256 proposalId + ) public view virtual override(Governor, GovernorSuperQuorum) returns (ProposalState) { + return super.state(proposalId); + } +} diff --git a/contracts/interfaces/IERC1271.sol b/contracts/interfaces/IERC1271.sol index 8c239942a..71e0b72b6 100644 --- a/contracts/interfaces/IERC1271.sol +++ b/contracts/interfaces/IERC1271.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1271.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/IERC1271.sol) pragma solidity ^0.8.20; @@ -11,7 +11,7 @@ interface IERC1271 { /** * @dev Should return whether the signature provided is valid for the provided data * @param hash Hash of the data to be signed - * @param signature Signature byte array associated with _data + * @param signature Signature byte array associated with `hash` */ function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue); } diff --git a/contracts/interfaces/IERC4626.sol b/contracts/interfaces/IERC4626.sol index 8ebadd72f..ce55f72e1 100644 --- a/contracts/interfaces/IERC4626.sol +++ b/contracts/interfaces/IERC4626.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC4626.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/IERC4626.sol) pragma solidity ^0.8.20; @@ -198,7 +198,7 @@ interface IERC4626 is IERC20, IERC20Metadata { function maxRedeem(address owner) external view returns (uint256 maxShares); /** - * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, + * @dev Allows an on-chain or off-chain user to simulate the effects of their redemption at the current block, * given current on-chain conditions. * * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call diff --git a/contracts/interfaces/README.adoc b/contracts/interfaces/README.adoc index 61aae05d1..703cd15b5 100644 --- a/contracts/interfaces/README.adoc +++ b/contracts/interfaces/README.adoc @@ -40,6 +40,10 @@ are useful to interact with third party contracts that implement them. - {IERC5313} - {IERC5805} - {IERC6372} +- {IERC6909} +- {IERC6909ContentURI} +- {IERC6909Metadata} +- {IERC6909TokenSupply} - {IERC7674} == Detailed ABI @@ -74,12 +78,22 @@ are useful to interact with third party contracts that implement them. {{IERC4626}} -{{IERC5313}} +{{IERC4906}} {{IERC5267}} +{{IERC5313}} + {{IERC5805}} {{IERC6372}} +{{IERC6909}} + +{{IERC6909ContentURI}} + +{{IERC6909Metadata}} + +{{IERC6909TokenSupply}} + {{IERC7674}} diff --git a/contracts/interfaces/draft-IERC4337.sol b/contracts/interfaces/draft-IERC4337.sol index 2aa526db6..62fbe4b64 100644 --- a/contracts/interfaces/draft-IERC4337.sol +++ b/contracts/interfaces/draft-IERC4337.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (interfaces/draft-IERC4337.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/draft-IERC4337.sol) pragma solidity ^0.8.20; @@ -21,7 +21,7 @@ pragma solidity ^0.8.20; * - `paymasterData` (`bytes`): Data for paymaster (only if paymaster exists) * - `signature` (`bytes`): Data passed into the account to verify authorization * - * When passed to on-chain contacts, the following packed version is used. + * When passed to on-chain contracts, the following packed version is used. * - `sender` (`address`) * - `nonce` (`uint256`) * - `initCode` (`bytes`): concatenation of factory address and factoryData (or empty) @@ -164,13 +164,13 @@ interface IEntryPoint is IEntryPointNonces, IEntryPointStake { /** * @dev Executes a batch of user operations. - * @param beneficiary Address to which gas is refunded up completing the execution. + * @param beneficiary Address to which gas is refunded upon completing the execution. */ function handleOps(PackedUserOperation[] calldata ops, address payable beneficiary) external; /** * @dev Executes a batch of aggregated user operations per aggregator. - * @param beneficiary Address to which gas is refunded up completing the execution. + * @param beneficiary Address to which gas is refunded upon completing the execution. */ function handleAggregatedOps( UserOpsPerAggregator[] calldata opsPerAggregator, diff --git a/contracts/interfaces/draft-IERC6909.sol b/contracts/interfaces/draft-IERC6909.sol new file mode 100644 index 000000000..c6d550d65 --- /dev/null +++ b/contracts/interfaces/draft-IERC6909.sol @@ -0,0 +1,125 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/draft-IERC6909.sol) + +pragma solidity ^0.8.20; + +import {IERC165} from "../utils/introspection/IERC165.sol"; + +/** + * @dev Required interface of an ERC-6909 compliant contract, as defined in the + * https://eips.ethereum.org/EIPS/eip-6909[ERC]. + */ +interface IERC6909 is IERC165 { + /** + * @dev Emitted when the allowance of a `spender` for an `owner` is set for a token of type `id`. + * The new allowance is `amount`. + */ + event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount); + + /** + * @dev Emitted when `owner` grants or revokes operator status for a `spender`. + */ + event OperatorSet(address indexed owner, address indexed spender, bool approved); + + /** + * @dev Emitted when `amount` tokens of type `id` are moved from `sender` to `receiver` initiated by `caller`. + */ + event Transfer( + address caller, + address indexed sender, + address indexed receiver, + uint256 indexed id, + uint256 amount + ); + + /** + * @dev Returns the amount of tokens of type `id` owned by `owner`. + */ + function balanceOf(address owner, uint256 id) external view returns (uint256); + + /** + * @dev Returns the amount of tokens of type `id` that `spender` is allowed to spend on behalf of `owner`. + * + * NOTE: Does not include operator allowances. + */ + function allowance(address owner, address spender, uint256 id) external view returns (uint256); + + /** + * @dev Returns true if `spender` is set as an operator for `owner`. + */ + function isOperator(address owner, address spender) external view returns (bool); + + /** + * @dev Sets an approval to `spender` for `amount` of tokens of type `id` from the caller's tokens. An `amount` of + * `type(uint256).max` signifies an unlimited approval. + * + * Must return true. + */ + function approve(address spender, uint256 id, uint256 amount) external returns (bool); + + /** + * @dev Grants or revokes unlimited transfer permission of any token id to `spender` for the caller's tokens. + * + * Must return true. + */ + function setOperator(address spender, bool approved) external returns (bool); + + /** + * @dev Transfers `amount` of token type `id` from the caller's account to `receiver`. + * + * Must return true. + */ + function transfer(address receiver, uint256 id, uint256 amount) external returns (bool); + + /** + * @dev Transfers `amount` of token type `id` from `sender` to `receiver`. + * + * Must return true. + */ + function transferFrom(address sender, address receiver, uint256 id, uint256 amount) external returns (bool); +} + +/** + * @dev Optional extension of {IERC6909} that adds metadata functions. + */ +interface IERC6909Metadata is IERC6909 { + /** + * @dev Returns the name of the token of type `id`. + */ + function name(uint256 id) external view returns (string memory); + + /** + * @dev Returns the ticker symbol of the token of type `id`. + */ + function symbol(uint256 id) external view returns (string memory); + + /** + * @dev Returns the number of decimals for the token of type `id`. + */ + function decimals(uint256 id) external view returns (uint8); +} + +/** + * @dev Optional extension of {IERC6909} that adds content URI functions. + */ +interface IERC6909ContentURI is IERC6909 { + /** + * @dev Returns URI for the contract. + */ + function contractURI() external view returns (string memory); + + /** + * @dev Returns the URI for the token of type `id`. + */ + function tokenURI(uint256 id) external view returns (string memory); +} + +/** + * @dev Optional extension of {IERC6909} that adds a token supply function. + */ +interface IERC6909TokenSupply is IERC6909 { + /** + * @dev Returns the total supply of the token of type `id`. + */ + function totalSupply(uint256 id) external view returns (uint256); +} diff --git a/contracts/interfaces/draft-IERC7579.sol b/contracts/interfaces/draft-IERC7579.sol index 077d9783f..dbe991542 100644 --- a/contracts/interfaces/draft-IERC7579.sol +++ b/contracts/interfaces/draft-IERC7579.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (interfaces/draft-IERC7579.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (interfaces/draft-IERC7579.sol) pragma solidity ^0.8.20; import {PackedUserOperation} from "./draft-IERC4337.sol"; @@ -15,7 +15,7 @@ uint256 constant MODULE_TYPE_HOOK = 4; interface IERC7579Module { /** * @dev This function is called by the smart account during installation of the module - * @param data arbitrary data that may be required on the module during `onInstall` initialization + * @param data arbitrary data that may be passed to the module during `onInstall` initialization * * MUST revert on error (e.g. if module is already enabled) */ @@ -23,7 +23,7 @@ interface IERC7579Module { /** * @dev This function is called by the smart account during uninstallation of the module - * @param data arbitrary data that may be required on the module during `onUninstall` de-initialization + * @param data arbitrary data that may be passed to the module during `onUninstall` de-initialization * * MUST revert on error */ @@ -186,7 +186,7 @@ interface IERC7579ModuleConfig { * @dev Installs a Module of a certain type on the smart account * @param moduleTypeId the module type ID according to the ERC-7579 spec * @param module the module address - * @param initData arbitrary data that may be required on the module during `onInstall` + * @param initData arbitrary data that may be passed to the module during `onInstall` * initialization. * * MUST implement authorization control @@ -200,8 +200,8 @@ interface IERC7579ModuleConfig { * @dev Uninstalls a Module of a certain type on the smart account * @param moduleTypeId the module type ID according the ERC-7579 spec * @param module the module address - * @param deInitData arbitrary data that may be required on the module during `onInstall` - * initialization. + * @param deInitData arbitrary data that may be passed to the module during `onUninstall` + * deinitialization. * * MUST implement authorization control * MUST call `onUninstall` on the module with the `deInitData` parameter if provided @@ -214,7 +214,7 @@ interface IERC7579ModuleConfig { * @dev Returns whether a module is installed on the smart account * @param moduleTypeId the module type ID according the ERC-7579 spec * @param module the module address - * @param additionalContext arbitrary data that may be required to determine if the module is installed + * @param additionalContext arbitrary data that may be passed to determine if the module is installed * * MUST return true if the module is installed and false otherwise */ diff --git a/contracts/metatx/ERC2771Forwarder.sol b/contracts/metatx/ERC2771Forwarder.sol index 4a069874e..a463e70e0 100644 --- a/contracts/metatx/ERC2771Forwarder.sol +++ b/contracts/metatx/ERC2771Forwarder.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (metatx/ERC2771Forwarder.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (metatx/ERC2771Forwarder.sol) pragma solidity ^0.8.20; @@ -302,8 +302,11 @@ contract ERC2771Forwarder is EIP712, Nonces { * * This function performs a static call to the target contract calling the * {ERC2771Context-isTrustedForwarder} function. + * + * NOTE: Consider the execution of this forwarder is permissionless. Without this check, anyone may transfer assets + * that are owned by, or are approved to this forwarder. */ - function _isTrustedByTarget(address target) private view returns (bool) { + function _isTrustedByTarget(address target) internal view virtual returns (bool) { bytes memory encodedParams = abi.encodeCall(ERC2771Context.isTrustedForwarder, (address(this))); bool success; diff --git a/contracts/mocks/AuthorityMock.sol b/contracts/mocks/AuthorityMock.sol index 4f3e1de3a..cd2356ec1 100644 --- a/contracts/mocks/AuthorityMock.sol +++ b/contracts/mocks/AuthorityMock.sol @@ -12,7 +12,7 @@ contract NotAuthorityMock is IAuthority { } contract AuthorityNoDelayMock is IAuthority { - bool _immediate; + bool private _immediate; function canCall( address /* caller */, @@ -28,14 +28,14 @@ contract AuthorityNoDelayMock is IAuthority { } contract AuthorityDelayMock { - bool _immediate; - uint32 _delay; + bool private _immediate; + uint256 private _delay; function canCall( address /* caller */, address /* target */, bytes4 /* selector */ - ) external view returns (bool immediate, uint32 delay) { + ) external view returns (bool immediate, uint256 delay) { return (_immediate, _delay); } @@ -43,7 +43,7 @@ contract AuthorityDelayMock { _immediate = immediate; } - function _setDelay(uint32 delay) external { + function _setDelay(uint256 delay) external { _delay = delay; } } diff --git a/contracts/mocks/MerkleTreeMock.sol b/contracts/mocks/MerkleTreeMock.sol index dcde6b658..48ee1a6e4 100644 --- a/contracts/mocks/MerkleTreeMock.sol +++ b/contracts/mocks/MerkleTreeMock.sol @@ -14,6 +14,7 @@ contract MerkleTreeMock { bytes32 public root; event LeafInserted(bytes32 leaf, uint256 index, bytes32 root); + event LeafUpdated(bytes32 oldLeaf, bytes32 newLeaf, uint256 index, bytes32 root); function setup(uint8 _depth, bytes32 _zero) public { root = _tree.setup(_depth, _zero); @@ -25,6 +26,13 @@ contract MerkleTreeMock { root = currentRoot; } + function update(uint256 index, bytes32 oldValue, bytes32 newValue, bytes32[] memory proof) public { + (bytes32 oldRoot, bytes32 newRoot) = _tree.update(index, oldValue, newValue, proof); + if (oldRoot != root) revert MerkleTree.MerkleTreeUpdateInvalidProof(); + emit LeafUpdated(oldValue, newValue, index, newRoot); + root = newRoot; + } + function depth() public view returns (uint256) { return _tree.depth(); } diff --git a/contracts/mocks/docs/access-control/AccessControlModified.sol b/contracts/mocks/docs/access-control/AccessControlModified.sol index 9994afc92..479fa2079 100644 --- a/contracts/mocks/docs/access-control/AccessControlModified.sol +++ b/contracts/mocks/docs/access-control/AccessControlModified.sol @@ -5,10 +5,10 @@ pragma solidity ^0.8.20; import {AccessControl} from "../../../access/AccessControl.sol"; contract AccessControlModified is AccessControl { - error AccessControlNonRevokable(); + error AccessControlNonRevocable(); // Override the revokeRole function function revokeRole(bytes32, address) public pure override { - revert AccessControlNonRevokable(); + revert AccessControlNonRevocable(); } } diff --git a/contracts/mocks/docs/token/ERC6909/ERC6909GameItems.sol b/contracts/mocks/docs/token/ERC6909/ERC6909GameItems.sol new file mode 100644 index 000000000..611e1dd66 --- /dev/null +++ b/contracts/mocks/docs/token/ERC6909/ERC6909GameItems.sol @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {ERC6909Metadata} from "../../../../token/ERC6909/extensions/draft-ERC6909Metadata.sol"; + +contract ERC6909GameItems is ERC6909Metadata { + uint256 public constant GOLD = 0; + uint256 public constant SILVER = 1; + uint256 public constant THORS_HAMMER = 2; + uint256 public constant SWORD = 3; + uint256 public constant SHIELD = 4; + + constructor() { + _setDecimals(GOLD, 18); + _setDecimals(SILVER, 18); + // Default decimals is 0 + _setDecimals(SWORD, 9); + _setDecimals(SHIELD, 9); + + _mint(msg.sender, GOLD, 10 ** 18); + _mint(msg.sender, SILVER, 10_000 ** 18); + _mint(msg.sender, THORS_HAMMER, 1); + _mint(msg.sender, SWORD, 10 ** 9); + _mint(msg.sender, SHIELD, 10 ** 9); + } +} diff --git a/contracts/mocks/governance/GovernorProposalGuardianMock.sol b/contracts/mocks/governance/GovernorProposalGuardianMock.sol new file mode 100644 index 000000000..5ed45d6c9 --- /dev/null +++ b/contracts/mocks/governance/GovernorProposalGuardianMock.sol @@ -0,0 +1,27 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.20; + +import {Governor} from "../../governance/Governor.sol"; +import {GovernorSettings} from "../../governance/extensions/GovernorSettings.sol"; +import {GovernorCountingSimple} from "../../governance/extensions/GovernorCountingSimple.sol"; +import {GovernorVotesQuorumFraction} from "../../governance/extensions/GovernorVotesQuorumFraction.sol"; +import {GovernorProposalGuardian} from "../../governance/extensions/GovernorProposalGuardian.sol"; + +abstract contract GovernorProposalGuardianMock is + GovernorSettings, + GovernorVotesQuorumFraction, + GovernorCountingSimple, + GovernorProposalGuardian +{ + function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) { + return super.proposalThreshold(); + } + + function _validateCancel( + uint256 proposalId, + address caller + ) internal view override(Governor, GovernorProposalGuardian) returns (bool) { + return super._validateCancel(proposalId, caller); + } +} diff --git a/contracts/mocks/governance/GovernorSequentialProposalIdMock.sol b/contracts/mocks/governance/GovernorSequentialProposalIdMock.sol new file mode 100644 index 000000000..882ee0b24 --- /dev/null +++ b/contracts/mocks/governance/GovernorSequentialProposalIdMock.sol @@ -0,0 +1,39 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.20; + +import {Governor} from "../../governance/Governor.sol"; +import {GovernorSettings} from "../../governance/extensions/GovernorSettings.sol"; +import {GovernorCountingSimple} from "../../governance/extensions/GovernorCountingSimple.sol"; +import {GovernorVotesQuorumFraction} from "../../governance/extensions/GovernorVotesQuorumFraction.sol"; +import {GovernorSequentialProposalId} from "../../governance/extensions/GovernorSequentialProposalId.sol"; + +abstract contract GovernorSequentialProposalIdMock is + GovernorSettings, + GovernorVotesQuorumFraction, + GovernorCountingSimple, + GovernorSequentialProposalId +{ + function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) { + return super.proposalThreshold(); + } + + function getProposalId( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash + ) public view virtual override(Governor, GovernorSequentialProposalId) returns (uint256) { + return super.getProposalId(targets, values, calldatas, descriptionHash); + } + + function _propose( + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + string memory description, + address proposer + ) internal virtual override(Governor, GovernorSequentialProposalId) returns (uint256 proposalId) { + return super._propose(targets, values, calldatas, description, proposer); + } +} diff --git a/contracts/mocks/governance/GovernorSuperQuorumMock.sol b/contracts/mocks/governance/GovernorSuperQuorumMock.sol new file mode 100644 index 000000000..2a48dbb7c --- /dev/null +++ b/contracts/mocks/governance/GovernorSuperQuorumMock.sol @@ -0,0 +1,95 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.20; + +import {Governor} from "../../governance/Governor.sol"; +import {GovernorSettings} from "../../governance/extensions/GovernorSettings.sol"; +import {GovernorVotes} from "../../governance/extensions/GovernorVotes.sol"; +import {GovernorSuperQuorum} from "../../governance/extensions/GovernorSuperQuorum.sol"; +import {GovernorCountingSimple} from "../../governance/extensions/GovernorCountingSimple.sol"; +import {GovernorTimelockControl} from "../../governance/extensions/GovernorTimelockControl.sol"; + +abstract contract GovernorSuperQuorumMock is + GovernorSettings, + GovernorVotes, + GovernorTimelockControl, + GovernorSuperQuorum, + GovernorCountingSimple +{ + uint256 private _quorum; + uint256 private _superQuorum; + + constructor(uint256 quorum_, uint256 superQuorum_) { + _quorum = quorum_; + _superQuorum = superQuorum_; + } + + function quorum(uint256) public view override returns (uint256) { + return _quorum; + } + + function superQuorum(uint256) public view override returns (uint256) { + return _superQuorum; + } + + function state( + uint256 proposalId + ) public view override(Governor, GovernorSuperQuorum, GovernorTimelockControl) returns (ProposalState) { + return super.state(proposalId); + } + + function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) { + return super.proposalThreshold(); + } + + function proposalVotes( + uint256 proposalId + ) + public + view + virtual + override(GovernorCountingSimple, GovernorSuperQuorum) + returns (uint256 againstVotes, uint256 forVotes, uint256 abstainVotes) + { + return super.proposalVotes(proposalId); + } + + 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 _executeOperations( + uint256 proposalId, + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash + ) internal override(Governor, GovernorTimelockControl) { + super._executeOperations(proposalId, targets, values, calldatas, descriptionHash); + } + + function _executor() internal view override(Governor, GovernorTimelockControl) returns (address) { + return super._executor(); + } + + function _queueOperations( + uint256 proposalId, + address[] memory targets, + uint256[] memory values, + bytes[] memory calldatas, + bytes32 descriptionHash + ) internal override(Governor, GovernorTimelockControl) returns (uint48) { + return super._queueOperations(proposalId, targets, values, calldatas, descriptionHash); + } + + function proposalNeedsQueuing( + uint256 proposalId + ) public view override(Governor, GovernorTimelockControl) returns (bool) { + return super.proposalNeedsQueuing(proposalId); + } +} diff --git a/contracts/mocks/governance/GovernorVotesSuperQuorumFractionMock.sol b/contracts/mocks/governance/GovernorVotesSuperQuorumFractionMock.sol new file mode 100644 index 000000000..4967b033b --- /dev/null +++ b/contracts/mocks/governance/GovernorVotesSuperQuorumFractionMock.sol @@ -0,0 +1,37 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.20; + +import {Governor} from "../../governance/Governor.sol"; +import {GovernorSettings} from "../../governance/extensions/GovernorSettings.sol"; +import {GovernorSuperQuorum} from "../../governance/extensions/GovernorSuperQuorum.sol"; +import {GovernorCountingSimple} from "../../governance/extensions/GovernorCountingSimple.sol"; +import {GovernorVotesSuperQuorumFraction} from "../../governance/extensions/GovernorVotesSuperQuorumFraction.sol"; + +abstract contract GovernorVotesSuperQuorumFractionMock is + GovernorSettings, + GovernorVotesSuperQuorumFraction, + GovernorCountingSimple +{ + function proposalThreshold() public view override(Governor, GovernorSettings) returns (uint256) { + return super.proposalThreshold(); + } + + function proposalVotes( + uint256 proposalId + ) + public + view + virtual + override(GovernorCountingSimple, GovernorSuperQuorum) + returns (uint256 againstVotes, uint256 forVotes, uint256 abstainVotes) + { + return super.proposalVotes(proposalId); + } + + function state( + uint256 proposalId + ) public view override(Governor, GovernorVotesSuperQuorumFraction) returns (ProposalState) { + return super.state(proposalId); + } +} diff --git a/contracts/mocks/token/ERC20ForceApproveMock.sol b/contracts/mocks/token/ERC20ForceApproveMock.sol index 36c0f574d..aecfb9e0f 100644 --- a/contracts/mocks/token/ERC20ForceApproveMock.sol +++ b/contracts/mocks/token/ERC20ForceApproveMock.sol @@ -4,7 +4,7 @@ pragma solidity ^0.8.20; import {ERC20} from "../../token/ERC20/ERC20.sol"; -// contract that replicate USDT (0xdac17f958d2ee523a2206206994597c13d831ec7) approval behavior +// contract that replicates USDT (0xdac17f958d2ee523a2206206994597c13d831ec7) approval behavior abstract contract ERC20ForceApproveMock is ERC20 { function approve(address spender, uint256 amount) public virtual override returns (bool) { require(amount == 0 || allowance(msg.sender, spender) == 0, "USDT approval failure"); diff --git a/contracts/package.json b/contracts/package.json index 3682eadeb..70ae73bc2 100644 --- a/contracts/package.json +++ b/contracts/package.json @@ -1,7 +1,7 @@ { "name": "@openzeppelin/contracts", "description": "Secure Smart Contract library for Solidity", - "version": "5.2.0", + "version": "5.3.0", "files": [ "**/*.sol", "/build/contracts/*.json", diff --git a/contracts/proxy/Clones.sol b/contracts/proxy/Clones.sol index 6b8d9cc6f..9bddf5116 100644 --- a/contracts/proxy/Clones.sol +++ b/contracts/proxy/Clones.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (proxy/Clones.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (proxy/Clones.sol) pragma solidity ^0.8.20; @@ -21,7 +21,7 @@ library Clones { error CloneArgumentsTooLong(); /** - * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. + * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`. * * This function uses the create opcode, which should never revert. */ @@ -54,7 +54,7 @@ library Clones { } /** - * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation`. + * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation`. * * This function uses the create2 opcode and a `salt` to deterministically deploy * the clone. Using the same `implementation` and `salt` multiple times will revert, since @@ -158,7 +158,7 @@ library Clones { } /** - * @dev Deploys and returns the address of a clone that mimics the behaviour of `implementation` with custom + * @dev Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom * immutable arguments. These are provided through `args` and cannot be changed after deployment. To * access the arguments within the implementation, use {fetchCloneArgs}. * diff --git a/contracts/proxy/utils/Initializable.sol b/contracts/proxy/utils/Initializable.sol index b3d82b586..0d05fdb0e 100644 --- a/contracts/proxy/utils/Initializable.sol +++ b/contracts/proxy/utils/Initializable.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.0) (proxy/utils/Initializable.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/Initializable.sol) pragma solidity ^0.8.20; @@ -112,7 +112,7 @@ abstract contract Initializable { // Allowed calls: // - initialSetup: the contract is not in the initializing state and no previous version was // initialized - // - construction: the contract is initialized at version 1 (no reininitialization) and the + // - construction: the contract is initialized at version 1 (no reinitialization) and the // current contract is just being deployed bool initialSetup = initialized == 0 && isTopLevelCall; bool construction = initialized == 1 && address(this).code.length == 0; @@ -216,13 +216,23 @@ abstract contract Initializable { return _getInitializableStorage()._initializing; } + /** + * @dev Pointer to storage slot. Allows integrators to override it with a custom storage location. + * + * NOTE: Consider following the ERC-7201 formula to derive storage locations. + */ + function _initializableStorageSlot() internal pure virtual returns (bytes32) { + return INITIALIZABLE_STORAGE; + } + /** * @dev Returns a pointer to the storage namespace. */ // solhint-disable-next-line var-name-mixedcase function _getInitializableStorage() private pure returns (InitializableStorage storage $) { + bytes32 slot = _initializableStorageSlot(); assembly { - $.slot := INITIALIZABLE_STORAGE + $.slot := slot } } } diff --git a/contracts/proxy/utils/UUPSUpgradeable.sol b/contracts/proxy/utils/UUPSUpgradeable.sol index 4719c023b..d0f58427f 100644 --- a/contracts/proxy/utils/UUPSUpgradeable.sol +++ b/contracts/proxy/utils/UUPSUpgradeable.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (proxy/utils/UUPSUpgradeable.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (proxy/utils/UUPSUpgradeable.sol) pragma solidity ^0.8.22; @@ -91,7 +91,6 @@ abstract contract UUPSUpgradeable is IERC1822Proxiable { /** * @dev Reverts if the execution is not performed via delegatecall or the execution * context is not of a proxy with an ERC-1967 compliant implementation pointing to self. - * See {_onlyProxy}. */ function _checkProxy() internal view virtual { if ( diff --git a/contracts/token/ERC1155/IERC1155.sol b/contracts/token/ERC1155/IERC1155.sol index 0da320fbe..ea1c0daba 100644 --- a/contracts/token/ERC1155/IERC1155.sol +++ b/contracts/token/ERC1155/IERC1155.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/IERC1155.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.20; @@ -81,7 +81,7 @@ interface IERC1155 is IERC165 { * @dev Transfers a `value` amount of tokens of type `id` from `from` to `to`. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens - * to an untrusted contract, when invoking {onERC1155Received} on the receiver. + * to an untrusted contract, when invoking {IERC1155Receiver-onERC1155Received} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * @@ -101,7 +101,7 @@ interface IERC1155 is IERC165 { * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * WARNING: This function can potentially allow a reentrancy attack when transferring tokens - * to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver. + * to an untrusted contract, when invoking {IERC1155Receiver-onERC1155BatchReceived} on the receiver. * Ensure to follow the checks-effects-interactions pattern and consider employing * reentrancy guards when interacting with untrusted contracts. * diff --git a/contracts/token/ERC1155/utils/ERC1155Utils.sol b/contracts/token/ERC1155/utils/ERC1155Utils.sol index 371cd86ba..346579393 100644 --- a/contracts/token/ERC1155/utils/ERC1155Utils.sol +++ b/contracts/token/ERC1155/utils/ERC1155Utils.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC1155/utils/ERC1155Utils.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC1155/utils/ERC1155Utils.sol) pragma solidity ^0.8.20; @@ -15,7 +15,7 @@ import {IERC1155Errors} from "../../../interfaces/draft-IERC6093.sol"; */ library ERC1155Utils { /** - * @dev Performs an acceptance check for the provided `operator` by calling {IERC1155-onERC1155Received} + * @dev Performs an acceptance check for the provided `operator` by calling {IERC1155Receiver-onERC1155Received} * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). * * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). @@ -50,7 +50,7 @@ library ERC1155Utils { } /** - * @dev Performs a batch acceptance check for the provided `operator` by calling {IERC1155-onERC1155BatchReceived} + * @dev Performs a batch acceptance check for the provided `operator` by calling {IERC1155Receiver-onERC1155BatchReceived} * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). * * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). diff --git a/contracts/token/ERC20/ERC20.sol b/contracts/token/ERC20/ERC20.sol index 471908d6c..13137bcf6 100644 --- a/contracts/token/ERC20/ERC20.sol +++ b/contracts/token/ERC20/ERC20.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/ERC20.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/ERC20.sol) pragma solidity ^0.8.20; @@ -39,8 +39,7 @@ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { /** * @dev Sets the values for {name} and {symbol}. * - * All two of these values are immutable: they can only be set once during - * construction. + * Both values are immutable: they can only be set once during construction. */ constructor(string memory name_, string memory symbol_) { _name = name_; @@ -241,7 +240,7 @@ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { } /** - * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens. + * @dev Sets `value` as the allowance of `spender` over the `owner`'s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. @@ -291,7 +290,7 @@ abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors { } /** - * @dev Updates `owner` s allowance for `spender` based on spent `value`. + * @dev Updates `owner`'s allowance for `spender` based on spent `value`. * * Does not update the allowance value in case of infinite allowance. * Revert if not enough allowance is available. diff --git a/contracts/token/ERC20/README.adoc b/contracts/token/ERC20/README.adoc index bfbe6790b..1b4d31d2e 100644 --- a/contracts/token/ERC20/README.adoc +++ b/contracts/token/ERC20/README.adoc @@ -7,11 +7,11 @@ This set of interfaces, contracts, and utilities are all related to the https:// TIP: For an overview of ERC-20 tokens and a walk through on how to create a token contract read our xref:ROOT:erc20.adoc[ERC-20 guide]. -There are a few core contracts that implement the behavior specified in the ERC: +There are a few core contracts that implement the behavior specified in the ERC-20 standard: * {IERC20}: the interface all ERC-20 implementations should conform to. -* {IERC20Metadata}: the extended ERC-20 interface including the <>, <> and <> functions. -* {ERC20}: the implementation of the ERC-20 interface, including the <>, <> and <> optional standard extension to the base interface. +* {IERC20Metadata}: the extended ERC-20 interface including the <>, <> and <> functions. +* {ERC20}: the implementation of the ERC-20 interface, including the <>, <> and <> optional extensions to the standard interface. Additionally there are multiple custom extensions, including: @@ -30,9 +30,9 @@ Finally, there are some utilities to interact with ERC-20 contracts in various w * {SafeERC20}: a wrapper around the interface that eliminates the need to handle boolean return values. -Other utilities that support ERC-20 assets can be found in codebase: +Other utilities that support ERC-20 assets can be found in the codebase: -* ERC-20 tokens can be timelocked (held tokens for a beneficiary until a specified time) or vested (released following a given schedule) using a {VestingWallet}. +* ERC-20 tokens can be timelocked (held for a beneficiary until a specified time) or vested (released following a given schedule) using a {VestingWallet}. NOTE: This core set of contracts is designed to be unopinionated, allowing developers to access the internal functions in ERC-20 (such as <>) and expose them as external functions in the way they prefer. diff --git a/contracts/token/ERC20/extensions/ERC4626.sol b/contracts/token/ERC20/extensions/ERC4626.sol index ec9a25507..2dc89e988 100644 --- a/contracts/token/ERC20/extensions/ERC4626.sol +++ b/contracts/token/ERC20/extensions/ERC4626.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/ERC4626.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/extensions/ERC4626.sol) pragma solidity ^0.8.20; @@ -34,7 +34,7 @@ import {Math} from "../../../utils/math/Math.sol"; * offset (0) makes it non-profitable even if an attacker is able to capture value from multiple user deposits, as a result * of the value being captured by the virtual shares (out of the attacker's donation) matching the attacker's expected gains. * With a larger offset, the attack becomes orders of magnitude more expensive than it is profitable. More details about the - * underlying math can be found xref:erc4626.adoc#inflation-attack[here]. + * underlying math can be found xref:ROOT:erc4626.adoc#inflation-attack[here]. * * The drawback of this approach is that the virtual shares do capture (a very small) part of the value being accrued * to the vault. Also, if the vault experiences losses, the users try to exit the vault, the virtual shares and assets @@ -114,7 +114,7 @@ abstract contract ERC4626 is ERC20, IERC4626 { /** @dev See {IERC4626-totalAssets}. */ function totalAssets() public view virtual returns (uint256) { - return _asset.balanceOf(address(this)); + return IERC20(asset()).balanceOf(address(this)); } /** @dev See {IERC4626-convertToShares}. */ @@ -237,14 +237,14 @@ abstract contract ERC4626 is ERC20, IERC4626 { * @dev Deposit/mint common workflow. */ function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual { - // If _asset is ERC-777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the + // If asset() is ERC-777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the // `tokensToSend` hook. On the other hand, the `tokenReceived` hook, that is triggered after the transfer, // calls the vault, which is assumed not malicious. // // Conclusion: we need to do the transfer before we mint so that any reentrancy would happen before the // assets are transferred and before the shares are minted, which is a valid state. // slither-disable-next-line reentrancy-no-eth - SafeERC20.safeTransferFrom(_asset, caller, address(this), assets); + SafeERC20.safeTransferFrom(IERC20(asset()), caller, address(this), assets); _mint(receiver, shares); emit Deposit(caller, receiver, assets, shares); @@ -264,14 +264,14 @@ abstract contract ERC4626 is ERC20, IERC4626 { _spendAllowance(owner, caller, shares); } - // If _asset is ERC-777, `transfer` can trigger a reentrancy AFTER the transfer happens through the + // If asset() is ERC-777, `transfer` can trigger a reentrancy AFTER the transfer happens through the // `tokensReceived` hook. On the other hand, the `tokensToSend` hook, that is triggered before the transfer, // calls the vault, which is assumed not malicious. // // Conclusion: we need to do the transfer after the burn so that any reentrancy would happen after the // shares are burned and after the assets are transferred, which is a valid state. _burn(owner, shares); - SafeERC20.safeTransfer(_asset, receiver, assets); + SafeERC20.safeTransfer(IERC20(asset()), receiver, assets); emit Withdraw(caller, receiver, owner, assets, shares); } diff --git a/contracts/token/ERC20/extensions/draft-ERC20TemporaryApproval.sol b/contracts/token/ERC20/extensions/draft-ERC20TemporaryApproval.sol index d30521b49..357daa937 100644 --- a/contracts/token/ERC20/extensions/draft-ERC20TemporaryApproval.sol +++ b/contracts/token/ERC20/extensions/draft-ERC20TemporaryApproval.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/draft-ERC20TemporaryApproval.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/extensions/draft-ERC20TemporaryApproval.sol) pragma solidity ^0.8.24; @@ -61,7 +61,7 @@ abstract contract ERC20TemporaryApproval is ERC20, IERC7674 { } /** - * @dev Sets `value` as the temporary allowance of `spender` over the `owner` s tokens. + * @dev Sets `value` as the temporary allowance of `spender` over the `owner`'s tokens. * * This internal function is equivalent to `temporaryApprove`, and can be used to e.g. set automatic allowances * for certain subsystems, etc. diff --git a/contracts/token/ERC20/utils/SafeERC20.sol b/contracts/token/ERC20/utils/SafeERC20.sol index edac165bc..883e8d30c 100644 --- a/contracts/token/ERC20/utils/SafeERC20.sol +++ b/contracts/token/ERC20/utils/SafeERC20.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (token/ERC20/utils/SafeERC20.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.20; @@ -42,6 +42,20 @@ library SafeERC20 { _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value))); } + /** + * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful. + */ + function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) { + return _callOptionalReturnBool(token, abi.encodeCall(token.transfer, (to, value))); + } + + /** + * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful. + */ + function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) { + return _callOptionalReturnBool(token, abi.encodeCall(token.transferFrom, (from, to, value))); + } + /** * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value, * non-reverting calls are assumed to be successful. diff --git a/contracts/token/ERC6909/README.adoc b/contracts/token/ERC6909/README.adoc new file mode 100644 index 000000000..17d116cc4 --- /dev/null +++ b/contracts/token/ERC6909/README.adoc @@ -0,0 +1,27 @@ += ERC-6909 + +[.readme-notice] +NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/token/erc6909 + +This set of interfaces and contracts are all related to the https://eips.ethereum.org/EIPS/eip-6909[ERC-6909 Minimal Multi-Token Interface]. + +The ERC consists of four interfaces which fulfill different roles--the interfaces are as follows: + +. {IERC6909}: Base interface for a vanilla ERC6909 token. +. {IERC6909ContentURI}: Extends the base interface and adds content URI (contract and token level) functionality. +. {IERC6909Metadata}: Extends the base interface and adds metadata functionality, which exposes a name, symbol, and decimals for each token id. +. {IERC6909TokenSupply}: Extends the base interface and adds total supply functionality for each token id. + +Implementations are provided for each of the 4 interfaces defined in the ERC. + +== Core + +{{ERC6909}} + +== Extensions + +{{ERC6909ContentURI}} + +{{ERC6909Metadata}} + +{{ERC6909TokenSupply}} diff --git a/contracts/token/ERC6909/draft-ERC6909.sol b/contracts/token/ERC6909/draft-ERC6909.sol new file mode 100644 index 000000000..6f5cdd6a8 --- /dev/null +++ b/contracts/token/ERC6909/draft-ERC6909.sol @@ -0,0 +1,224 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC6909/draft-ERC6909.sol) + +pragma solidity ^0.8.20; + +import {IERC6909} from "../../interfaces/draft-IERC6909.sol"; +import {Context} from "../../utils/Context.sol"; +import {IERC165, ERC165} from "../../utils/introspection/ERC165.sol"; + +/** + * @dev Implementation of ERC-6909. + * See https://eips.ethereum.org/EIPS/eip-6909 + */ +contract ERC6909 is Context, ERC165, IERC6909 { + mapping(address owner => mapping(uint256 id => uint256)) private _balances; + + mapping(address owner => mapping(address operator => bool)) private _operatorApprovals; + + mapping(address owner => mapping(address spender => mapping(uint256 id => uint256))) private _allowances; + + error ERC6909InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 id); + error ERC6909InsufficientAllowance(address spender, uint256 allowance, uint256 needed, uint256 id); + error ERC6909InvalidApprover(address approver); + error ERC6909InvalidReceiver(address receiver); + error ERC6909InvalidSender(address sender); + error ERC6909InvalidSpender(address spender); + + /// @inheritdoc IERC165 + function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { + return interfaceId == type(IERC6909).interfaceId || super.supportsInterface(interfaceId); + } + + /// @inheritdoc IERC6909 + function balanceOf(address owner, uint256 id) public view virtual override returns (uint256) { + return _balances[owner][id]; + } + + /// @inheritdoc IERC6909 + function allowance(address owner, address spender, uint256 id) public view virtual override returns (uint256) { + return _allowances[owner][spender][id]; + } + + /// @inheritdoc IERC6909 + function isOperator(address owner, address spender) public view virtual override returns (bool) { + return _operatorApprovals[owner][spender]; + } + + /// @inheritdoc IERC6909 + function approve(address spender, uint256 id, uint256 amount) public virtual override returns (bool) { + _approve(_msgSender(), spender, id, amount); + return true; + } + + /// @inheritdoc IERC6909 + function setOperator(address spender, bool approved) public virtual override returns (bool) { + _setOperator(_msgSender(), spender, approved); + return true; + } + + /// @inheritdoc IERC6909 + function transfer(address receiver, uint256 id, uint256 amount) public virtual override returns (bool) { + _transfer(_msgSender(), receiver, id, amount); + return true; + } + + /// @inheritdoc IERC6909 + function transferFrom( + address sender, + address receiver, + uint256 id, + uint256 amount + ) public virtual override returns (bool) { + address caller = _msgSender(); + if (sender != caller && !isOperator(sender, caller)) { + _spendAllowance(sender, caller, id, amount); + } + _transfer(sender, receiver, id, amount); + return true; + } + + /** + * @dev Creates `amount` of token `id` and assigns them to `account`, by transferring it from address(0). + * Relies on the `_update` mechanism. + * + * Emits a {Transfer} event with `from` set to the zero address. + * + * NOTE: This function is not virtual, {_update} should be overridden instead. + */ + function _mint(address to, uint256 id, uint256 amount) internal { + if (to == address(0)) { + revert ERC6909InvalidReceiver(address(0)); + } + _update(address(0), to, id, amount); + } + + /** + * @dev Moves `amount` of token `id` from `from` to `to` without checking for approvals. This function verifies + * that neither the sender nor the receiver are address(0), which means it cannot mint or burn tokens. + * Relies on the `_update` mechanism. + * + * Emits a {Transfer} event. + * + * NOTE: This function is not virtual, {_update} should be overridden instead. + */ + function _transfer(address from, address to, uint256 id, uint256 amount) internal { + if (from == address(0)) { + revert ERC6909InvalidSender(address(0)); + } + if (to == address(0)) { + revert ERC6909InvalidReceiver(address(0)); + } + _update(from, to, id, amount); + } + + /** + * @dev Destroys a `amount` of token `id` from `account`. + * Relies on the `_update` mechanism. + * + * Emits a {Transfer} event with `to` set to the zero address. + * + * NOTE: This function is not virtual, {_update} should be overridden instead + */ + function _burn(address from, uint256 id, uint256 amount) internal { + if (from == address(0)) { + revert ERC6909InvalidSender(address(0)); + } + _update(from, address(0), id, amount); + } + + /** + * @dev Transfers `amount` of token `id` from `from` to `to`, or alternatively mints (or burns) if `from` + * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding + * this function. + * + * Emits a {Transfer} event. + */ + function _update(address from, address to, uint256 id, uint256 amount) internal virtual { + address caller = _msgSender(); + + if (from != address(0)) { + uint256 fromBalance = _balances[from][id]; + if (fromBalance < amount) { + revert ERC6909InsufficientBalance(from, fromBalance, amount, id); + } + unchecked { + // Overflow not possible: amount <= fromBalance. + _balances[from][id] = fromBalance - amount; + } + } + if (to != address(0)) { + _balances[to][id] += amount; + } + + emit Transfer(caller, from, to, id, amount); + } + + /** + * @dev Sets `amount` as the allowance of `spender` over the `owner`'s `id` tokens. + * + * This internal function is equivalent to `approve`, and can be used to e.g. set automatic allowances for certain + * subsystems, etc. + * + * Emits an {Approval} event. + * + * Requirements: + * + * - `owner` cannot be the zero address. + * - `spender` cannot be the zero address. + */ + function _approve(address owner, address spender, uint256 id, uint256 amount) internal virtual { + if (owner == address(0)) { + revert ERC6909InvalidApprover(address(0)); + } + if (spender == address(0)) { + revert ERC6909InvalidSpender(address(0)); + } + _allowances[owner][spender][id] = amount; + emit Approval(owner, spender, id, amount); + } + + /** + * @dev Approve `spender` to operate on all of `owner`'s tokens + * + * This internal function is equivalent to `setOperator`, and can be used to e.g. set automatic allowances for + * certain subsystems, etc. + * + * Emits an {OperatorSet} event. + * + * Requirements: + * + * - `owner` cannot be the zero address. + * - `spender` cannot be the zero address. + */ + function _setOperator(address owner, address spender, bool approved) internal virtual { + if (owner == address(0)) { + revert ERC6909InvalidApprover(address(0)); + } + if (spender == address(0)) { + revert ERC6909InvalidSpender(address(0)); + } + _operatorApprovals[owner][spender] = approved; + emit OperatorSet(owner, spender, approved); + } + + /** + * @dev Updates `owner`'s allowance for `spender` based on spent `amount`. + * + * Does not update the allowance value in case of infinite allowance. + * Revert if not enough allowance is available. + * + * Does not emit an {Approval} event. + */ + function _spendAllowance(address owner, address spender, uint256 id, uint256 amount) internal virtual { + uint256 currentAllowance = allowance(owner, spender, id); + if (currentAllowance < type(uint256).max) { + if (currentAllowance < amount) { + revert ERC6909InsufficientAllowance(spender, currentAllowance, amount, id); + } + unchecked { + _allowances[owner][spender][id] = currentAllowance - amount; + } + } + } +} diff --git a/contracts/token/ERC6909/extensions/draft-ERC6909ContentURI.sol b/contracts/token/ERC6909/extensions/draft-ERC6909ContentURI.sol new file mode 100644 index 000000000..9d082c066 --- /dev/null +++ b/contracts/token/ERC6909/extensions/draft-ERC6909ContentURI.sol @@ -0,0 +1,53 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC6909/extensions/draft-ERC6909ContentURI.sol) + +pragma solidity ^0.8.20; + +import {ERC6909} from "../draft-ERC6909.sol"; +import {IERC6909ContentURI} from "../../../interfaces/draft-IERC6909.sol"; + +/** + * @dev Implementation of the Content URI extension defined in ERC6909. + */ +contract ERC6909ContentURI is ERC6909, IERC6909ContentURI { + string private _contractURI; + mapping(uint256 id => string) private _tokenURIs; + + /// @dev Event emitted when the contract URI is changed. See https://eips.ethereum.org/EIPS/eip-7572[ERC-7572] for details. + event ContractURIUpdated(); + + /// @dev See {IERC1155-URI} + event URI(string value, uint256 indexed id); + + /// @inheritdoc IERC6909ContentURI + function contractURI() public view virtual override returns (string memory) { + return _contractURI; + } + + /// @inheritdoc IERC6909ContentURI + function tokenURI(uint256 id) public view virtual override returns (string memory) { + return _tokenURIs[id]; + } + + /** + * @dev Sets the {contractURI} for the contract. + * + * Emits a {ContractURIUpdated} event. + */ + function _setContractURI(string memory newContractURI) internal virtual { + _contractURI = newContractURI; + + emit ContractURIUpdated(); + } + + /** + * @dev Sets the {tokenURI} for a given token of type `id`. + * + * Emits a {URI} event. + */ + function _setTokenURI(uint256 id, string memory newTokenURI) internal virtual { + _tokenURIs[id] = newTokenURI; + + emit URI(newTokenURI, id); + } +} diff --git a/contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol b/contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol new file mode 100644 index 000000000..31efebe88 --- /dev/null +++ b/contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol @@ -0,0 +1,77 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC6909/extensions/draft-ERC6909Metadata.sol) + +pragma solidity ^0.8.20; + +import {ERC6909} from "../draft-ERC6909.sol"; +import {IERC6909Metadata} from "../../../interfaces/draft-IERC6909.sol"; + +/** + * @dev Implementation of the Metadata extension defined in ERC6909. Exposes the name, symbol, and decimals of each token id. + */ +contract ERC6909Metadata is ERC6909, IERC6909Metadata { + struct TokenMetadata { + string name; + string symbol; + uint8 decimals; + } + + mapping(uint256 id => TokenMetadata) private _tokenMetadata; + + /// @dev The name of the token of type `id` was updated to `newName`. + event ERC6909NameUpdated(uint256 indexed id, string newName); + + /// @dev The symbol for the token of type `id` was updated to `newSymbol`. + event ERC6909SymbolUpdated(uint256 indexed id, string newSymbol); + + /// @dev The decimals value for token of type `id` was updated to `newDecimals`. + event ERC6909DecimalsUpdated(uint256 indexed id, uint8 newDecimals); + + /// @inheritdoc IERC6909Metadata + function name(uint256 id) public view virtual override returns (string memory) { + return _tokenMetadata[id].name; + } + + /// @inheritdoc IERC6909Metadata + function symbol(uint256 id) public view virtual override returns (string memory) { + return _tokenMetadata[id].symbol; + } + + /// @inheritdoc IERC6909Metadata + function decimals(uint256 id) public view virtual override returns (uint8) { + return _tokenMetadata[id].decimals; + } + + /** + * @dev Sets the `name` for a given token of type `id`. + * + * Emits an {ERC6909NameUpdated} event. + */ + function _setName(uint256 id, string memory newName) internal virtual { + _tokenMetadata[id].name = newName; + + emit ERC6909NameUpdated(id, newName); + } + + /** + * @dev Sets the `symbol` for a given token of type `id`. + * + * Emits an {ERC6909SymbolUpdated} event. + */ + function _setSymbol(uint256 id, string memory newSymbol) internal virtual { + _tokenMetadata[id].symbol = newSymbol; + + emit ERC6909SymbolUpdated(id, newSymbol); + } + + /** + * @dev Sets the `decimals` for a given token of type `id`. + * + * Emits an {ERC6909DecimalsUpdated} event. + */ + function _setDecimals(uint256 id, uint8 newDecimals) internal virtual { + _tokenMetadata[id].decimals = newDecimals; + + emit ERC6909DecimalsUpdated(id, newDecimals); + } +} diff --git a/contracts/token/ERC6909/extensions/draft-ERC6909TokenSupply.sol b/contracts/token/ERC6909/extensions/draft-ERC6909TokenSupply.sol new file mode 100644 index 000000000..0fd4c224a --- /dev/null +++ b/contracts/token/ERC6909/extensions/draft-ERC6909TokenSupply.sol @@ -0,0 +1,35 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC6909/extensions/draft-ERC6909TokenSupply.sol) + +pragma solidity ^0.8.20; + +import {ERC6909} from "../draft-ERC6909.sol"; +import {IERC6909TokenSupply} from "../../../interfaces/draft-IERC6909.sol"; + +/** + * @dev Implementation of the Token Supply extension defined in ERC6909. + * Tracks the total supply of each token id individually. + */ +contract ERC6909TokenSupply is ERC6909, IERC6909TokenSupply { + mapping(uint256 id => uint256) private _totalSupplies; + + /// @inheritdoc IERC6909TokenSupply + function totalSupply(uint256 id) public view virtual override returns (uint256) { + return _totalSupplies[id]; + } + + /// @dev Override the `_update` function to update the total supply of each token id as necessary. + function _update(address from, address to, uint256 id, uint256 amount) internal virtual override { + super._update(from, to, id, amount); + + if (from == address(0)) { + _totalSupplies[id] += amount; + } + if (to == address(0)) { + unchecked { + // amount <= _balances[from][id] <= _totalSupplies[id] + _totalSupplies[id] -= amount; + } + } + } +} diff --git a/contracts/token/ERC721/README.adoc b/contracts/token/ERC721/README.adoc index 5554720d6..22a306235 100644 --- a/contracts/token/ERC721/README.adoc +++ b/contracts/token/ERC721/README.adoc @@ -3,7 +3,7 @@ [.readme-notice] NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/token/erc721 -This set of interfaces, contracts, and utilities are all related to the https://eips.ethereum.org/EIPS/eip-721[ERC-721 Non-Fungible Token Standard]. +This set of interfaces, contracts, and utilities is all related to the https://eips.ethereum.org/EIPS/eip-721[ERC-721 Non-Fungible Token Standard]. TIP: For a walk through on how to create an ERC-721 token read our xref:ROOT:erc721.adoc[ERC-721 guide]. @@ -22,7 +22,7 @@ OpenZeppelin Contracts provides implementations of all four interfaces: Additionally there are a few of other extensions: -* {ERC721Consecutive}: An implementation of https://eips.ethereum.org/EIPS/eip-2309[ERC-2309] for minting batchs of tokens during construction, in accordance with ERC-721. +* {ERC721Consecutive}: An implementation of https://eips.ethereum.org/EIPS/eip-2309[ERC-2309] for minting batches of tokens during construction, in accordance with ERC-721. * {ERC721URIStorage}: A more flexible but more expensive way of storing metadata. * {ERC721Votes}: Support for voting and vote delegation. * {ERC721Royalty}: A way to signal royalty information following ERC-2981. diff --git a/contracts/token/ERC721/extensions/ERC721Consecutive.sol b/contracts/token/ERC721/extensions/ERC721Consecutive.sol index 6b849d774..0f3267364 100644 --- a/contracts/token/ERC721/extensions/ERC721Consecutive.sol +++ b/contracts/token/ERC721/extensions/ERC721Consecutive.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721Consecutive.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC721/extensions/ERC721Consecutive.sol) pragma solidity ^0.8.20; @@ -159,7 +159,7 @@ abstract contract ERC721Consecutive is IERC2309, ERC721 { } /** - * @dev Used to offset the first token id in {_nextConsecutiveId} + * @dev Used to offset the first token id in `_nextConsecutiveId` */ function _firstConsecutiveId() internal view virtual returns (uint96) { return 0; diff --git a/contracts/token/ERC721/extensions/ERC721URIStorage.sol b/contracts/token/ERC721/extensions/ERC721URIStorage.sol index d8b4d8d1f..bbb0d4c53 100644 --- a/contracts/token/ERC721/extensions/ERC721URIStorage.sol +++ b/contracts/token/ERC721/extensions/ERC721URIStorage.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/extensions/ERC721URIStorage.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC721/extensions/ERC721URIStorage.sol) pragma solidity ^0.8.20; @@ -52,7 +52,7 @@ abstract contract ERC721URIStorage is IERC4906, ERC721 { /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * - * Emits {MetadataUpdate}. + * Emits {IERC4906-MetadataUpdate}. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { _tokenURIs[tokenId] = _tokenURI; diff --git a/contracts/token/ERC721/utils/ERC721Utils.sol b/contracts/token/ERC721/utils/ERC721Utils.sol index 2fd091afd..1ae7a600b 100644 --- a/contracts/token/ERC721/utils/ERC721Utils.sol +++ b/contracts/token/ERC721/utils/ERC721Utils.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC721/utils/ERC721Utils.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC721/utils/ERC721Utils.sol) pragma solidity ^0.8.20; @@ -15,7 +15,7 @@ import {IERC721Errors} from "../../../interfaces/draft-IERC6093.sol"; */ library ERC721Utils { /** - * @dev Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received} + * @dev Performs an acceptance check for the provided `operator` by calling {IERC721Receiver-onERC721Received} * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). * * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). diff --git a/contracts/token/common/ERC2981.sol b/contracts/token/common/ERC2981.sol index 8335e56ef..9c25e9b37 100644 --- a/contracts/token/common/ERC2981.sol +++ b/contracts/token/common/ERC2981.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (token/common/ERC2981.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (token/common/ERC2981.sol) pragma solidity ^0.8.20; @@ -39,7 +39,7 @@ abstract contract ERC2981 is IERC2981, ERC165 { error ERC2981InvalidDefaultRoyaltyReceiver(address receiver); /** - * @dev The royalty set for an specific `tokenId` is invalid (eg. (numerator / denominator) >= 1). + * @dev The royalty set for a specific `tokenId` is invalid (eg. (numerator / denominator) >= 1). */ error ERC2981InvalidTokenRoyalty(uint256 tokenId, uint256 numerator, uint256 denominator); diff --git a/contracts/utils/Arrays.sol b/contracts/utils/Arrays.sol index bd3401703..0c1f14e26 100644 --- a/contracts/utils/Arrays.sol +++ b/contracts/utils/Arrays.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/Arrays.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/Arrays.sol) // This file was procedurally generated from scripts/generate/templates/Arrays.js. pragma solidity ^0.8.20; @@ -448,7 +448,7 @@ library Arrays { } /** - * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. + * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ @@ -459,7 +459,7 @@ library Arrays { } /** - * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. + * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ @@ -470,7 +470,7 @@ library Arrays { } /** - * @dev Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. + * @dev Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ diff --git a/contracts/utils/Calldata.sol b/contracts/utils/Calldata.sol new file mode 100644 index 000000000..41860b29f --- /dev/null +++ b/contracts/utils/Calldata.sol @@ -0,0 +1,25 @@ +// SPDX-License-Identifier: MIT +// OpenZeppelin Contracts (last updated v5.3.0) (utils/Calldata.sol) + +pragma solidity ^0.8.20; + +/** + * @dev Helper library for manipulating objects in calldata. + */ +library Calldata { + // slither-disable-next-line write-after-write + function emptyBytes() internal pure returns (bytes calldata result) { + assembly ("memory-safe") { + result.offset := 0 + result.length := 0 + } + } + + // slither-disable-next-line write-after-write + function emptyString() internal pure returns (string calldata result) { + assembly ("memory-safe") { + result.offset := 0 + result.length := 0 + } + } +} diff --git a/contracts/utils/Multicall.sol b/contracts/utils/Multicall.sol index 0dd5b4adc..94222feb0 100644 --- a/contracts/utils/Multicall.sol +++ b/contracts/utils/Multicall.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.1) (utils/Multicall.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/Multicall.sol) pragma solidity ^0.8.20; @@ -13,10 +13,10 @@ import {Context} from "./Context.sol"; * careful about sending transactions invoking {multicall}. For example, a relay address that filters function * selectors won't filter calls nested within a {multicall} operation. * - * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {_msgSender}). + * NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {Context-_msgSender}). * If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data` * to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of - * {_msgSender} are not propagated to subcalls. + * {Context-_msgSender} are not propagated to subcalls. */ abstract contract Multicall is Context { /** diff --git a/contracts/utils/Pausable.sol b/contracts/utils/Pausable.sol index 312f1cb90..68e7d2681 100644 --- a/contracts/utils/Pausable.sol +++ b/contracts/utils/Pausable.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/Pausable.sol) pragma solidity ^0.8.20; @@ -37,13 +37,6 @@ abstract contract Pausable is Context { */ error ExpectedPause(); - /** - * @dev Initializes the contract in unpaused state. - */ - constructor() { - _paused = false; - } - /** * @dev Modifier to make a function callable only when the contract is not paused. * diff --git a/contracts/utils/README.adoc b/contracts/utils/README.adoc index 432b806e3..5151b4616 100644 --- a/contracts/utils/README.adoc +++ b/contracts/utils/README.adoc @@ -18,12 +18,12 @@ Miscellaneous contracts and libraries containing utility functions you can use t * {ReentrancyGuardTransient}: Variant of {ReentrancyGuard} that uses transient storage (https://eips.ethereum.org/EIPS/eip-1153[EIP-1153]). * {Pausable}: A common emergency response mechanism that can pause functionality while a remediation is pending. * {Nonces}: Utility for tracking and verifying address nonces that only increment. - * {NoncesKeyed}: Alternative to {Nonces}, that support key-ed nonces following https://eips.ethereum.org/EIPS/eip-4337#semi-abstracted-nonce-support[ERC-4337 speciciations]. + * {NoncesKeyed}: Alternative to {Nonces}, that support keyed nonces following https://eips.ethereum.org/EIPS/eip-4337#semi-abstracted-nonce-support[ERC-4337 specifications]. * {ERC165}, {ERC165Checker}: Utilities for inspecting interfaces supported by contracts. * {BitMaps}: A simple library to manage boolean value mapped to a numerical index in an efficient way. * {EnumerableMap}: A type like Solidity's https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`], but with key-value _enumeration_: this will let you know how many entries a mapping has, and iterate over them (which is not possible with `mapping`). * {EnumerableSet}: Like {EnumerableMap}, but for https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets]. Can be used to store privileged accounts, issued IDs, etc. - * {DoubleEndedQueue}: An implementation of a https://en.wikipedia.org/wiki/Double-ended_queue[double ended queue] whose values can be removed added or remove from both sides. Useful for FIFO and LIFO structures. + * {DoubleEndedQueue}: An implementation of a https://en.wikipedia.org/wiki/Double-ended_queue[double ended queue] whose values can be added or removed from both sides. Useful for FIFO and LIFO structures. * {CircularBuffer}: A data structure to store the last N values pushed to it. * {Checkpoints}: A data structure to store values mapped to a strictly increasing key. Can be used for storing and accessing values over time. * {Heap}: A library that implements a https://en.wikipedia.org/wiki/Binary_heap[binary heap] in storage. @@ -33,8 +33,9 @@ Miscellaneous contracts and libraries containing utility functions you can use t * {Arrays}: Collection of functions that operate on https://docs.soliditylang.org/en/latest/types.html#arrays[`arrays`]. * {Base64}: On-chain base64 and base64URL encoding according to https://datatracker.ietf.org/doc/html/rfc4648[RFC-4648]. * {Bytes}: Common operations on bytes objects. + * {Calldata}: Helpers for manipulating calldata. * {Strings}: Common operations for strings formatting. - * {ShortString}: Library to encode (and decode) short strings into (or from) a single bytes32 slot for optimizing costs. Short strings are limited to 31 characters. + * {ShortStrings}: Library to encode (and decode) short strings into (or from) a single bytes32 slot for optimizing costs. Short strings are limited to 31 characters. * {SlotDerivation}: Methods for deriving storage slot from ERC-7201 namespaces as well as from constructions such as mapping and arrays. * {StorageSlot}: Methods for accessing specific storage slots formatted as common primitive types. * {TransientSlot}: Primitives for reading from and writing to transient storage (only value types are currently supported). @@ -42,7 +43,7 @@ Miscellaneous contracts and libraries containing utility functions you can use t * {Context}: A utility for abstracting the sender and calldata in the current execution context. * {Packing}: A library for packing and unpacking multiple values into bytes32 * {Panic}: A library to revert with https://docs.soliditylang.org/en/v0.8.20/control-structures.html#panic-via-assert-and-error-via-require[Solidity panic codes]. - * {Comparators}: A library that contains comparator functions to use with with the {Heap} library. + * {Comparators}: A library that contains comparator functions to use with the {Heap} library. * {CAIP2}, {CAIP10}: Libraries for formatting and parsing CAIP-2 and CAIP-10 identifiers. [NOTE] @@ -128,6 +129,10 @@ Ethereum contracts have no native concept of an interface, so applications must {{Base64}} +{{Bytes}} + +{{Calldata}} + {{Strings}} {{ShortStrings}} @@ -147,3 +152,7 @@ Ethereum contracts have no native concept of an interface, so applications must {{Panic}} {{Comparators}} + +{{CAIP2}} + +{{CAIP10}} diff --git a/contracts/utils/ReentrancyGuardTransient.sol b/contracts/utils/ReentrancyGuardTransient.sol index 1a62e29da..a1318c86f 100644 --- a/contracts/utils/ReentrancyGuardTransient.sol +++ b/contracts/utils/ReentrancyGuardTransient.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuardTransient.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/ReentrancyGuardTransient.sol) pragma solidity ^0.8.24; @@ -38,7 +38,7 @@ abstract contract ReentrancyGuardTransient { } function _nonReentrantBefore() private { - // On the first call to nonReentrant, _status will be NOT_ENTERED + // On the first call to nonReentrant, REENTRANCY_GUARD_STORAGE.asBoolean().tload() will be false if (_reentrancyGuardEntered()) { revert ReentrancyGuardReentrantCall(); } diff --git a/contracts/utils/ShortStrings.sol b/contracts/utils/ShortStrings.sol index fb8bde516..81d713d4b 100644 --- a/contracts/utils/ShortStrings.sol +++ b/contracts/utils/ShortStrings.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/ShortStrings.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/ShortStrings.sol) pragma solidity ^0.8.20; @@ -95,7 +95,7 @@ library ShortStrings { } /** - * @dev Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}. + * @dev Decode a string that was encoded to `ShortString` or written to storage using {toShortStringWithFallback}. */ function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) { if (ShortString.unwrap(value) != FALLBACK_SENTINEL) { @@ -107,7 +107,7 @@ library ShortStrings { /** * @dev Return the length of a string that was encoded to `ShortString` or written to storage using - * {setWithFallback}. + * {toShortStringWithFallback}. * * WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of * actual characters as the UTF-8 encoding of a single character can span over multiple bytes. diff --git a/contracts/utils/SlotDerivation.sol b/contracts/utils/SlotDerivation.sol index 62d1545c6..df23efa28 100644 --- a/contracts/utils/SlotDerivation.sol +++ b/contracts/utils/SlotDerivation.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/SlotDerivation.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/SlotDerivation.sol) // This file was procedurally generated from scripts/generate/templates/SlotDerivation.js. pragma solidity ^0.8.20; @@ -19,7 +19,7 @@ pragma solidity ^0.8.20; * using SlotDerivation for bytes32; * * // Declare a namespace - * string private constant _NAMESPACE = "" // eg. OpenZeppelin.Slot + * string private constant _NAMESPACE = ""; // eg. OpenZeppelin.Slot * * function setValueInNamespace(uint256 key, address newValue) internal { * _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue; diff --git a/contracts/utils/Strings.sol b/contracts/utils/Strings.sol index 0360b4cab..e5aa2c550 100644 --- a/contracts/utils/Strings.sol +++ b/contracts/utils/Strings.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.2.0) (utils/Strings.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/Strings.sol) pragma solidity ^0.8.20; @@ -15,6 +15,14 @@ library Strings { bytes16 private constant HEX_DIGITS = "0123456789abcdef"; uint8 private constant ADDRESS_LENGTH = 20; + uint256 private constant SPECIAL_CHARS_LOOKUP = + (1 << 0x08) | // backspace + (1 << 0x09) | // tab + (1 << 0x0a) | // newline + (1 << 0x0c) | // form feed + (1 << 0x0d) | // carriage return + (1 << 0x22) | // double quote + (1 << 0x5c); // backslash /** * @dev The `value` string doesn't fit in the specified `length`. @@ -139,7 +147,7 @@ library Strings { } /** - * @dev Variant of {parseUint} that parses a substring of `input` located between position `begin` (included) and + * @dev Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: @@ -177,7 +185,7 @@ library Strings { } /** - * @dev Implementation of {tryParseUint} that does not check bounds. Caller should make sure that + * @dev Implementation of {tryParseUint-string-uint256-uint256} that does not check bounds. Caller should make sure that * `begin <= end <= input.length`. Other inputs would result in undefined behavior. */ function _tryParseUintUncheckedBounds( @@ -250,7 +258,7 @@ library Strings { } /** - * @dev Implementation of {tryParseInt} that does not check bounds. Caller should make sure that + * @dev Implementation of {tryParseInt-string-uint256-uint256} that does not check bounds. Caller should make sure that * `begin <= end <= input.length`. Other inputs would result in undefined behavior. */ function _tryParseIntUncheckedBounds( @@ -287,7 +295,7 @@ library Strings { } /** - * @dev Variant of {parseHexUint} that parses a substring of `input` located between position `begin` (included) and + * @dev Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: @@ -325,7 +333,7 @@ library Strings { } /** - * @dev Implementation of {tryParseHexUint} that does not check bounds. Caller should make sure that + * @dev Implementation of {tryParseHexUint-string-uint256-uint256} that does not check bounds. Caller should make sure that * `begin <= end <= input.length`. Other inputs would result in undefined behavior. */ function _tryParseHexUintUncheckedBounds( @@ -346,7 +354,7 @@ library Strings { result *= 16; unchecked { // Multiplying by 16 is equivalent to a shift of 4 bits (with additional overflow check). - // This guaratees that adding a value < 16 will not cause an overflow, hence the unchecked. + // This guarantees that adding a value < 16 will not cause an overflow, hence the unchecked. result += chr; } } @@ -364,7 +372,7 @@ library Strings { } /** - * @dev Variant of {parseAddress} that parses a substring of `input` located between position `begin` (included) and + * @dev Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and * `end` (excluded). * * Requirements: @@ -378,7 +386,7 @@ library Strings { /** * @dev Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly - * formatted address. See {parseAddress} requirements. + * formatted address. See {parseAddress-string} requirements. */ function tryParseAddress(string memory input) internal pure returns (bool success, address value) { return tryParseAddress(input, 0, bytes(input).length); @@ -386,7 +394,7 @@ library Strings { /** * @dev Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly - * formatted address. See {parseAddress} requirements. + * formatted address. See {parseAddress-string-uint256-uint256} requirements. */ function tryParseAddress( string memory input, @@ -426,6 +434,47 @@ library Strings { return value; } + /** + * @dev Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata. + * + * WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped. + * + * NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of + * RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode + * characters that are not in this range, but other tooling may provide different results. + */ + function escapeJSON(string memory input) internal pure returns (string memory) { + bytes memory buffer = bytes(input); + bytes memory output = new bytes(2 * buffer.length); // worst case scenario + uint256 outputLength = 0; + + for (uint256 i; i < buffer.length; ++i) { + bytes1 char = bytes1(_unsafeReadBytesOffset(buffer, i)); + if (((SPECIAL_CHARS_LOOKUP & (1 << uint8(char))) != 0)) { + output[outputLength++] = "\\"; + if (char == 0x08) output[outputLength++] = "b"; + else if (char == 0x09) output[outputLength++] = "t"; + else if (char == 0x0a) output[outputLength++] = "n"; + else if (char == 0x0c) output[outputLength++] = "f"; + else if (char == 0x0d) output[outputLength++] = "r"; + else if (char == 0x5c) output[outputLength++] = "\\"; + else if (char == 0x22) { + // solhint-disable-next-line quotes + output[outputLength++] = '"'; + } + } else { + output[outputLength++] = char; + } + } + // write the actual length and deallocate unused memory + assembly ("memory-safe") { + mstore(output, outputLength) + mstore(0x40, add(output, shl(5, shr(5, add(outputLength, 63))))) + } + + return string(output); + } + /** * @dev Reads a bytes32 from a bytes array without bounds checking. * diff --git a/contracts/utils/TransientSlot.sol b/contracts/utils/TransientSlot.sol index 25c57dd3f..f0caea13d 100644 --- a/contracts/utils/TransientSlot.sol +++ b/contracts/utils/TransientSlot.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/TransientSlot.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/TransientSlot.sol) // This file was procedurally generated from scripts/generate/templates/TransientSlot.js. pragma solidity ^0.8.24; @@ -32,7 +32,7 @@ pragma solidity ^0.8.24; */ library TransientSlot { /** - * @dev UDVT that represent a slot holding a address. + * @dev UDVT that represents a slot holding an address. */ type AddressSlot is bytes32; @@ -44,7 +44,7 @@ library TransientSlot { } /** - * @dev UDVT that represent a slot holding a bool. + * @dev UDVT that represents a slot holding a bool. */ type BooleanSlot is bytes32; @@ -56,7 +56,7 @@ library TransientSlot { } /** - * @dev UDVT that represent a slot holding a bytes32. + * @dev UDVT that represents a slot holding a bytes32. */ type Bytes32Slot is bytes32; @@ -68,7 +68,7 @@ library TransientSlot { } /** - * @dev UDVT that represent a slot holding a uint256. + * @dev UDVT that represents a slot holding a uint256. */ type Uint256Slot is bytes32; @@ -80,7 +80,7 @@ library TransientSlot { } /** - * @dev UDVT that represent a slot holding a int256. + * @dev UDVT that represents a slot holding a int256. */ type Int256Slot is bytes32; diff --git a/contracts/utils/cryptography/EIP712.sol b/contracts/utils/cryptography/EIP712.sol index f15a67bd9..8ac545a8f 100644 --- a/contracts/utils/cryptography/EIP712.sol +++ b/contracts/utils/cryptography/EIP712.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/EIP712.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/EIP712.sol) pragma solidity ^0.8.20; @@ -48,7 +48,9 @@ abstract contract EIP712 is IERC5267 { ShortString private immutable _name; ShortString private immutable _version; + // slither-disable-next-line constable-states string private _nameFallback; + // slither-disable-next-line constable-states string private _versionFallback; /** @@ -109,7 +111,7 @@ abstract contract EIP712 is IERC5267 { } /** - * @dev See {IERC-5267}. + * @inheritdoc IERC5267 */ function eip712Domain() public diff --git a/contracts/utils/cryptography/Hashes.sol b/contracts/utils/cryptography/Hashes.sol index 893883164..48c9bbe2d 100644 --- a/contracts/utils/cryptography/Hashes.sol +++ b/contracts/utils/cryptography/Hashes.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/Hashes.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/Hashes.sol) pragma solidity ^0.8.20; @@ -15,13 +15,13 @@ library Hashes { * NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. */ function commutativeKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32) { - return a < b ? _efficientKeccak256(a, b) : _efficientKeccak256(b, a); + return a < b ? efficientKeccak256(a, b) : efficientKeccak256(b, a); } /** * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory. */ - function _efficientKeccak256(bytes32 a, bytes32 b) private pure returns (bytes32 value) { + function efficientKeccak256(bytes32 a, bytes32 b) internal pure returns (bytes32 value) { assembly ("memory-safe") { mstore(0x00, a) mstore(0x20, b) diff --git a/contracts/utils/cryptography/MessageHashUtils.sol b/contracts/utils/cryptography/MessageHashUtils.sol index e1cbccb65..37e92395f 100644 --- a/contracts/utils/cryptography/MessageHashUtils.sol +++ b/contracts/utils/cryptography/MessageHashUtils.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/MessageHashUtils.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/MessageHashUtils.sol) pragma solidity ^0.8.20; @@ -19,7 +19,7 @@ library MessageHashUtils { * * The digest is calculated by prefixing a bytes32 `messageHash` with * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the - * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. + * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method. * * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with * keccak256, although any bytes32 value can be safely used because the final digest will @@ -41,7 +41,7 @@ library MessageHashUtils { * * The digest is calculated by prefixing an arbitrary `message` with * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the - * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. + * hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method. * * See {ECDSA-recover}. */ @@ -63,6 +63,21 @@ library MessageHashUtils { return keccak256(abi.encodePacked(hex"19_00", validator, data)); } + /** + * @dev Variant of {toDataWithIntendedValidatorHash-address-bytes} optimized for cases where `data` is a bytes32. + */ + function toDataWithIntendedValidatorHash( + address validator, + bytes32 messageHash + ) internal pure returns (bytes32 digest) { + assembly ("memory-safe") { + mstore(0x00, hex"19_00") + mstore(0x02, shl(96, validator)) + mstore(0x16, messageHash) + digest := keccak256(0x00, 0x36) + } + } + /** * @dev Returns the keccak256 digest of an EIP-712 typed data (ERC-191 version `0x01`). * diff --git a/contracts/utils/cryptography/P256.sol b/contracts/utils/cryptography/P256.sol index 510eb55e7..81d79adc4 100644 --- a/contracts/utils/cryptography/P256.sol +++ b/contracts/utils/cryptography/P256.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/cryptography/P256.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/cryptography/P256.sol) pragma solidity ^0.8.20; import {Math} from "../math/Math.sol"; @@ -90,10 +90,48 @@ library P256 { ) private view returns (bool valid, bool supported) { if (!_isProperSignature(r, s) || !isValidPublicKey(qx, qy)) { return (false, true); // signature is invalid, and its not because the precompile is missing + } else if (_rip7212(h, r, s, qx, qy)) { + return (true, true); // precompile is present, signature is valid + } else if ( + // Given precompiles have no bytecode (i.e. `address(0x100).code.length == 0`), we use + // a valid signature with small `r` and `s` values to check if the precompile is present. Taken from + // https://github.com/C2SP/wycheproof/blob/4672ff74d68766e7785c2cac4c597effccef2c5c/testvectors/ecdsa_secp256r1_sha256_p1363_test.json#L1173-L1204 + _rip7212( + 0xbb5a52f42f9c9261ed4361f59422a1e30036e7c32b270c8807a419feca605023, // sha256("123400") + 0x0000000000000000000000000000000000000000000000000000000000000005, + 0x0000000000000000000000000000000000000000000000000000000000000001, + 0xa71af64de5126a4a4e02b7922d66ce9415ce88a4c9d25514d91082c8725ac957, + 0x5d47723c8fbe580bb369fec9c2665d8e30a435b9932645482e7c9f11e872296b + ) + ) { + return (false, true); // precompile is present, signature is invalid + } else { + return (false, false); // precompile is absent } + } - (bool success, bytes memory returndata) = address(0x100).staticcall(abi.encode(h, r, s, qx, qy)); - return (success && returndata.length == 0x20) ? (abi.decode(returndata, (bool)), true) : (false, false); + /** + * @dev Low level helper for {_tryVerifyNative}. Calls the precompile and checks if there is a return value. + */ + function _rip7212(bytes32 h, bytes32 r, bytes32 s, bytes32 qx, bytes32 qy) private view returns (bool isValid) { + assembly ("memory-safe") { + // Use the free memory pointer without updating it at the end of the function + let ptr := mload(0x40) + mstore(ptr, h) + mstore(add(ptr, 0x20), r) + mstore(add(ptr, 0x40), s) + mstore(add(ptr, 0x60), qx) + mstore(add(ptr, 0x80), qy) + // RIP-7212 precompiles return empty bytes when an invalid signature is passed, making it impossible + // to distinguish the presence of the precompile. Custom precompile implementations may decide to + // return `bytes32(0)` (i.e. false) without developers noticing, so we decide to evaluate the return value + // without expanding memory using scratch space. + mstore(0x00, 0) // zero out scratch space in case the precompile doesn't return anything + if iszero(staticcall(gas(), 0x100, ptr, 0xa0, 0x00, 0x20)) { + invalid() + } + isValid := mload(0x00) + } } /** diff --git a/contracts/utils/math/Math.sol b/contracts/utils/math/Math.sol index 85a420b1a..f0d608a2d 100644 --- a/contracts/utils/math/Math.sol +++ b/contracts/utils/math/Math.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/math/Math.sol) pragma solidity ^0.8.20; @@ -18,38 +18,68 @@ library Math { } /** - * @dev Returns the addition of two unsigned integers, with an success flag (no overflow). + * @dev Return the 512-bit addition of two uint256. + * + * The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low. + */ + function add512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) { + assembly ("memory-safe") { + low := add(a, b) + high := lt(low, a) + } + } + + /** + * @dev Return the 512-bit multiplication of two uint256. + * + * The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low. + */ + function mul512(uint256 a, uint256 b) internal pure returns (uint256 high, uint256 low) { + // 512-bit multiply [high low] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use + // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 + // variables such that product = high * 2²⁵⁶ + low. + assembly ("memory-safe") { + let mm := mulmod(a, b, not(0)) + low := mul(a, b) + high := sub(sub(mm, low), lt(mm, low)) + } + } + + /** + * @dev Returns the addition of two unsigned integers, with a success flag (no overflow). */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { uint256 c = a + b; - if (c < a) return (false, 0); - return (true, c); + success = c >= a; + result = c * SafeCast.toUint(success); } } /** - * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow). + * @dev Returns the subtraction of two unsigned integers, with a success flag (no overflow). */ function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { - if (b > a) return (false, 0); - return (true, a - b); + uint256 c = a - b; + success = c <= a; + result = c * SafeCast.toUint(success); } } /** - * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow). + * @dev Returns the multiplication of two unsigned integers, with a success flag (no overflow). */ function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { - // Gas optimization: this is cheaper than requiring 'a' not being zero, but the - // benefit is lost if 'b' is also tested. - // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 - if (a == 0) return (true, 0); uint256 c = a * b; - if (c / a != b) return (false, 0); - return (true, c); + assembly ("memory-safe") { + // Only true when the multiplication doesn't overflow + // (c / a == b) || (a == 0) + success := or(eq(div(c, a), b), iszero(a)) + } + // equivalent to: success ? c : 0 + result = c * SafeCast.toUint(success); } } @@ -58,8 +88,11 @@ library Math { */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { - if (b == 0) return (false, 0); - return (true, a / b); + success = b > 0; + assembly ("memory-safe") { + // The `DIV` opcode returns zero when the denominator is 0. + result := div(a, b) + } } } @@ -68,11 +101,38 @@ library Math { */ function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) { unchecked { - if (b == 0) return (false, 0); - return (true, a % b); + success = b > 0; + assembly ("memory-safe") { + // The `MOD` opcode returns zero when the denominator is 0. + result := mod(a, b) + } } } + /** + * @dev Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing. + */ + function saturatingAdd(uint256 a, uint256 b) internal pure returns (uint256) { + (bool success, uint256 result) = tryAdd(a, b); + return ternary(success, result, type(uint256).max); + } + + /** + * @dev Unsigned saturating subtraction, bounds to zero instead of overflowing. + */ + function saturatingSub(uint256 a, uint256 b) internal pure returns (uint256) { + (, uint256 result) = trySub(a, b); + return result; + } + + /** + * @dev Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing. + */ + function saturatingMul(uint256 a, uint256 b) internal pure returns (uint256) { + (bool success, uint256 result) = tryMul(a, b); + return ternary(success, result, type(uint256).max); + } + /** * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant. * @@ -143,26 +203,18 @@ library Math { */ function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) { unchecked { - // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use - // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 - // variables such that product = prod1 * 2²⁵⁶ + prod0. - uint256 prod0 = x * y; // Least significant 256 bits of the product - uint256 prod1; // Most significant 256 bits of the product - assembly { - let mm := mulmod(x, y, not(0)) - prod1 := sub(sub(mm, prod0), lt(mm, prod0)) - } + (uint256 high, uint256 low) = mul512(x, y); // Handle non-overflow cases, 256 by 256 division. - if (prod1 == 0) { + if (high == 0) { // Solidity will revert if denominator == 0, unlike the div opcode on its own. // The surrounding unchecked block does not change this fact. // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic. - return prod0 / denominator; + return low / denominator; } // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0. - if (denominator <= prod1) { + if (denominator <= high) { Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW)); } @@ -170,34 +222,34 @@ library Math { // 512 by 256 division. /////////////////////////////////////////////// - // Make division exact by subtracting the remainder from [prod1 prod0]. + // Make division exact by subtracting the remainder from [high low]. uint256 remainder; - assembly { + assembly ("memory-safe") { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. - prod1 := sub(prod1, gt(remainder, prod0)) - prod0 := sub(prod0, remainder) + high := sub(high, gt(remainder, low)) + low := sub(low, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. // Always >= 1. See https://cs.stackexchange.com/q/138556/92363. uint256 twos = denominator & (0 - denominator); - assembly { + assembly ("memory-safe") { // Divide denominator by twos. denominator := div(denominator, twos) - // Divide [prod1 prod0] by twos. - prod0 := div(prod0, twos) + // Divide [high low] by twos. + low := div(low, twos) // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } - // Shift in bits from prod1 into prod0. - prod0 |= prod1 * twos; + // Shift in bits from high into low. + low |= high * twos; // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for @@ -215,9 +267,9 @@ library Math { // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is - // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1 + // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and high // is no longer required. - result = prod0 * inverse; + result = low * inverse; return result; } } @@ -229,6 +281,26 @@ library Math { return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0); } + /** + * @dev Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256. + */ + function mulShr(uint256 x, uint256 y, uint8 n) internal pure returns (uint256 result) { + unchecked { + (uint256 high, uint256 low) = mul512(x, y); + if (high >= 1 << n) { + Panic.panic(Panic.UNDER_OVERFLOW); + } + return (high << (256 - n)) | (low >> n); + } + } + + /** + * @dev Calculates x * y >> n with full precision, following the selected rounding direction. + */ + function mulShr(uint256 x, uint256 y, uint8 n, Rounding rounding) internal pure returns (uint256) { + return mulShr(x, y, n) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, 1 << n) > 0); + } + /** * @dev Calculate the modular multiplicative inverse of a number in Z/nZ. * @@ -537,41 +609,45 @@ library Math { * @dev Return the log in base 2 of a positive value rounded towards zero. * Returns 0 if given 0. */ - function log2(uint256 value) internal pure returns (uint256) { - uint256 result = 0; - uint256 exp; - unchecked { - exp = 128 * SafeCast.toUint(value > (1 << 128) - 1); - value >>= exp; - result += exp; + function log2(uint256 x) internal pure returns (uint256 r) { + // If value has upper 128 bits set, log2 result is at least 128 + r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7; + // If upper 64 bits of 128-bit half set, add 64 to result + r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6; + // If upper 32 bits of 64-bit half set, add 32 to result + r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5; + // If upper 16 bits of 32-bit half set, add 16 to result + r |= SafeCast.toUint((x >> r) > 0xffff) << 4; + // If upper 8 bits of 16-bit half set, add 8 to result + r |= SafeCast.toUint((x >> r) > 0xff) << 3; + // If upper 4 bits of 8-bit half set, add 4 to result + r |= SafeCast.toUint((x >> r) > 0xf) << 2; - exp = 64 * SafeCast.toUint(value > (1 << 64) - 1); - value >>= exp; - result += exp; - - exp = 32 * SafeCast.toUint(value > (1 << 32) - 1); - value >>= exp; - result += exp; - - exp = 16 * SafeCast.toUint(value > (1 << 16) - 1); - value >>= exp; - result += exp; - - exp = 8 * SafeCast.toUint(value > (1 << 8) - 1); - value >>= exp; - result += exp; - - exp = 4 * SafeCast.toUint(value > (1 << 4) - 1); - value >>= exp; - result += exp; - - exp = 2 * SafeCast.toUint(value > (1 << 2) - 1); - value >>= exp; - result += exp; - - result += SafeCast.toUint(value > 1); + // Shifts value right by the current result and use it as an index into this lookup table: + // + // | x (4 bits) | index | table[index] = MSB position | + // |------------|---------|-----------------------------| + // | 0000 | 0 | table[0] = 0 | + // | 0001 | 1 | table[1] = 0 | + // | 0010 | 2 | table[2] = 1 | + // | 0011 | 3 | table[3] = 1 | + // | 0100 | 4 | table[4] = 2 | + // | 0101 | 5 | table[5] = 2 | + // | 0110 | 6 | table[6] = 2 | + // | 0111 | 7 | table[7] = 2 | + // | 1000 | 8 | table[8] = 3 | + // | 1001 | 9 | table[9] = 3 | + // | 1010 | 10 | table[10] = 3 | + // | 1011 | 11 | table[11] = 3 | + // | 1100 | 12 | table[12] = 3 | + // | 1101 | 13 | table[13] = 3 | + // | 1110 | 14 | table[14] = 3 | + // | 1111 | 15 | table[15] = 3 | + // + // The lookup table is represented as a 32-byte value with the MSB positions for 0-15 in the last 16 bytes. + assembly ("memory-safe") { + r := or(r, byte(shr(r, x), 0x0000010102020202030303030303030300000000000000000000000000000000)) } - return result; } /** @@ -640,29 +716,17 @@ library Math { * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ - function log256(uint256 value) internal pure returns (uint256) { - uint256 result = 0; - uint256 isGt; - unchecked { - isGt = SafeCast.toUint(value > (1 << 128) - 1); - value >>= isGt * 128; - result += isGt * 16; - - isGt = SafeCast.toUint(value > (1 << 64) - 1); - value >>= isGt * 64; - result += isGt * 8; - - isGt = SafeCast.toUint(value > (1 << 32) - 1); - value >>= isGt * 32; - result += isGt * 4; - - isGt = SafeCast.toUint(value > (1 << 16) - 1); - value >>= isGt * 16; - result += isGt * 2; - - result += SafeCast.toUint(value > (1 << 8) - 1); - } - return result; + function log256(uint256 x) internal pure returns (uint256 r) { + // If value has upper 128 bits set, log2 result is at least 128 + r = SafeCast.toUint(x > 0xffffffffffffffffffffffffffffffff) << 7; + // If upper 64 bits of 128-bit half set, add 64 to result + r |= SafeCast.toUint((x >> r) > 0xffffffffffffffff) << 6; + // If upper 32 bits of 64-bit half set, add 32 to result + r |= SafeCast.toUint((x >> r) > 0xffffffff) << 5; + // If upper 16 bits of 32-bit half set, add 16 to result + r |= SafeCast.toUint((x >> r) > 0xffff) << 4; + // Add 1 if upper 8 bits of 16-bit half set, and divide accumulated result by 8 + return (r >> 3) | SafeCast.toUint((x >> r) > 0xff); } /** diff --git a/contracts/utils/structs/Checkpoints.sol b/contracts/utils/structs/Checkpoints.sol index 8d8f13031..8ad3c5ab5 100644 --- a/contracts/utils/structs/Checkpoints.sol +++ b/contracts/utils/structs/Checkpoints.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/Checkpoints.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/Checkpoints.sol) // This file was procedurally generated from scripts/generate/templates/Checkpoints.js. pragma solidity ^0.8.20; @@ -114,7 +114,7 @@ library Checkpoints { } /** - * @dev Returns the number of checkpoint. + * @dev Returns the number of checkpoints. */ function length(Trace224 storage self) internal view returns (uint256) { return self._checkpoints.length; @@ -317,7 +317,7 @@ library Checkpoints { } /** - * @dev Returns the number of checkpoint. + * @dev Returns the number of checkpoints. */ function length(Trace208 storage self) internal view returns (uint256) { return self._checkpoints.length; @@ -520,7 +520,7 @@ library Checkpoints { } /** - * @dev Returns the number of checkpoint. + * @dev Returns the number of checkpoints. */ function length(Trace160 storage self) internal view returns (uint256) { return self._checkpoints.length; diff --git a/contracts/utils/structs/CircularBuffer.sol b/contracts/utils/structs/CircularBuffer.sol index ae0a4a88f..43ce89be7 100644 --- a/contracts/utils/structs/CircularBuffer.sol +++ b/contracts/utils/structs/CircularBuffer.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/CircularBuffer.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/CircularBuffer.sol) pragma solidity ^0.8.20; import {Math} from "../math/Math.sol"; @@ -62,7 +62,7 @@ library CircularBuffer { } /** - * @dev Initialize a new CircularBuffer of given size. + * @dev Initialize a new CircularBuffer of a given size. * * If the CircularBuffer was already setup and used, calling that function again will reset it to a blank state. * diff --git a/contracts/utils/structs/EnumerableMap.sol b/contracts/utils/structs/EnumerableMap.sol index 4e12acec1..09fa498fc 100644 --- a/contracts/utils/structs/EnumerableMap.sol +++ b/contracts/utils/structs/EnumerableMap.sol @@ -1,5 +1,5 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/EnumerableMap.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/EnumerableMap.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableMap.js. pragma solidity ^0.8.20; @@ -16,6 +16,7 @@ import {EnumerableSet} from "./EnumerableSet.sol"; * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. + * - Map can be cleared (all entries removed) in O(n). * * ```solidity * contract Example { @@ -90,6 +91,20 @@ library EnumerableMap { return map._keys.remove(key); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(Bytes32ToBytes32Map storage map) internal { + uint256 len = length(map); + for (uint256 i = 0; i < len; ++i) { + delete map._values[map._keys.at(i)]; + } + map._keys.clear(); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -185,6 +200,16 @@ library EnumerableMap { return remove(map._inner, bytes32(key)); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(UintToUintMap storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -278,6 +303,16 @@ library EnumerableMap { return remove(map._inner, bytes32(key)); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(UintToAddressMap storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -371,6 +406,16 @@ library EnumerableMap { return remove(map._inner, bytes32(key)); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(UintToBytes32Map storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -464,6 +509,16 @@ library EnumerableMap { return remove(map._inner, bytes32(uint256(uint160(key)))); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(AddressToUintMap storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -557,6 +612,16 @@ library EnumerableMap { return remove(map._inner, bytes32(uint256(uint160(key)))); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(AddressToAddressMap storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -650,6 +715,16 @@ library EnumerableMap { return remove(map._inner, bytes32(uint256(uint160(key)))); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(AddressToBytes32Map storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -743,6 +818,16 @@ library EnumerableMap { return remove(map._inner, key); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(Bytes32ToUintMap storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ @@ -836,6 +921,16 @@ library EnumerableMap { return remove(map._inner, key); } + /** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(Bytes32ToAddressMap storage map) internal { + clear(map._inner); + } + /** * @dev Returns true if the key is in the map. O(1). */ diff --git a/contracts/utils/structs/EnumerableSet.sol b/contracts/utils/structs/EnumerableSet.sol index 065202e82..ec8bb3779 100644 --- a/contracts/utils/structs/EnumerableSet.sol +++ b/contracts/utils/structs/EnumerableSet.sol @@ -1,9 +1,11 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/EnumerableSet.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/EnumerableSet.sol) // This file was procedurally generated from scripts/generate/templates/EnumerableSet.js. pragma solidity ^0.8.20; +import {Arrays} from "../Arrays.sol"; + /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive @@ -14,6 +16,7 @@ pragma solidity ^0.8.20; * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. + * - Set can be cleared (all elements removed) in O(n). * * ```solidity * contract Example { @@ -114,6 +117,20 @@ library EnumerableSet { } } + /** + * @dev Removes all the values from a set. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + */ + function _clear(Set storage set) private { + uint256 len = _length(set); + for (uint256 i = 0; i < len; ++i) { + delete set._positions[set._values[i]]; + } + Arrays.unsafeSetLength(set._values, 0); + } + /** * @dev Returns true if the value is in the set. O(1). */ @@ -180,6 +197,16 @@ library EnumerableSet { return _remove(set._inner, value); } + /** + * @dev Removes all the values from a set. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(Bytes32Set storage set) internal { + _clear(set._inner); + } + /** * @dev Returns true if the value is in the set. O(1). */ @@ -253,6 +280,16 @@ library EnumerableSet { return _remove(set._inner, bytes32(uint256(uint160(value)))); } + /** + * @dev Removes all the values from a set. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(AddressSet storage set) internal { + _clear(set._inner); + } + /** * @dev Returns true if the value is in the set. O(1). */ @@ -326,6 +363,16 @@ library EnumerableSet { return _remove(set._inner, bytes32(value)); } + /** + * @dev Removes all the values from a set. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + */ + function clear(UintSet storage set) internal { + _clear(set._inner); + } + /** * @dev Returns true if the value is in the set. O(1). */ diff --git a/contracts/utils/structs/MerkleTree.sol b/contracts/utils/structs/MerkleTree.sol index 56f5bc672..010ccfe8b 100644 --- a/contracts/utils/structs/MerkleTree.sol +++ b/contracts/utils/structs/MerkleTree.sol @@ -1,11 +1,12 @@ // SPDX-License-Identifier: MIT -// OpenZeppelin Contracts (last updated v5.1.0) (utils/structs/MerkleTree.sol) +// OpenZeppelin Contracts (last updated v5.3.0) (utils/structs/MerkleTree.sol) pragma solidity ^0.8.20; import {Hashes} from "../cryptography/Hashes.sol"; import {Arrays} from "../Arrays.sol"; import {Panic} from "../Panic.sol"; +import {StorageSlot} from "../StorageSlot.sol"; /** * @dev Library for managing https://wikipedia.org/wiki/Merkle_Tree[Merkle Tree] data structures. @@ -27,6 +28,12 @@ import {Panic} from "../Panic.sol"; * _Available since v5.1._ */ library MerkleTree { + /// @dev Error emitted when trying to update a leaf that was not previously pushed. + error MerkleTreeUpdateInvalidIndex(uint256 index, uint256 length); + + /// @dev Error emitted when the proof used during an update is invalid (could not reproduce the side). + error MerkleTreeUpdateInvalidProof(); + /** * @dev A complete `bytes32` Merkle tree. * @@ -88,7 +95,7 @@ library MerkleTree { // Build each root of zero-filled subtrees bytes32 currentZero = zero; - for (uint32 i = 0; i < treeDepth; ++i) { + for (uint256 i = 0; i < treeDepth; ++i) { Arrays.unsafeAccess(self._zeros, i).value = currentZero; currentZero = fnHash(currentZero, currentZero); } @@ -143,7 +150,7 @@ library MerkleTree { // Rebuild branch from leaf to root uint256 currentIndex = index; bytes32 currentLevelHash = leaf; - for (uint32 i = 0; i < treeDepth; i++) { + for (uint256 i = 0; i < treeDepth; i++) { // Reaching the parent node, is currentLevelHash the left child? bool isLeft = currentIndex % 2 == 0; @@ -166,6 +173,91 @@ library MerkleTree { return (index, currentLevelHash); } + /** + * @dev Change the value of the leaf at position `index` from `oldValue` to `newValue`. Returns the recomputed "old" + * root (before the update) and "new" root (after the update). The caller must verify that the reconstructed old + * root is the last known one. + * + * The `proof` must be an up-to-date inclusion proof for the leaf being updated. This means that this function is + * vulnerable to front-running. Any {push} or {update} operation (that changes the root of the tree) would render + * all "in flight" updates invalid. + * + * This variant uses {Hashes-commutativeKeccak256} to hash internal nodes. It should only be used on merkle trees + * that were setup using the same (default) hashing function (i.e. by calling + * {xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-}[the default setup] function). + */ + function update( + Bytes32PushTree storage self, + uint256 index, + bytes32 oldValue, + bytes32 newValue, + bytes32[] memory proof + ) internal returns (bytes32 oldRoot, bytes32 newRoot) { + return update(self, index, oldValue, newValue, proof, Hashes.commutativeKeccak256); + } + + /** + * @dev Change the value of the leaf at position `index` from `oldValue` to `newValue`. Returns the recomputed "old" + * root (before the update) and "new" root (after the update). The caller must verify that the reconstructed old + * root is the last known one. + * + * The `proof` must be an up-to-date inclusion proof for the leaf being update. This means that this function is + * vulnerable to front-running. Any {push} or {update} operation (that changes the root of the tree) would render + * all "in flight" updates invalid. + * + * This variant uses a custom hashing function to hash internal nodes. It should only be called with the same + * function as the one used during the initial setup of the merkle tree. + */ + function update( + Bytes32PushTree storage self, + uint256 index, + bytes32 oldValue, + bytes32 newValue, + bytes32[] memory proof, + function(bytes32, bytes32) view returns (bytes32) fnHash + ) internal returns (bytes32 oldRoot, bytes32 newRoot) { + unchecked { + // Check index range + uint256 length = self._nextLeafIndex; + if (index >= length) revert MerkleTreeUpdateInvalidIndex(index, length); + + // Cache read + uint256 treeDepth = depth(self); + + // Workaround stack too deep + bytes32[] storage sides = self._sides; + + // This cannot overflow because: 0 <= index < length + uint256 lastIndex = length - 1; + uint256 currentIndex = index; + bytes32 currentLevelHashOld = oldValue; + bytes32 currentLevelHashNew = newValue; + for (uint32 i = 0; i < treeDepth; i++) { + bool isLeft = currentIndex % 2 == 0; + + lastIndex >>= 1; + currentIndex >>= 1; + + if (isLeft && currentIndex == lastIndex) { + StorageSlot.Bytes32Slot storage side = Arrays.unsafeAccess(sides, i); + if (side.value != currentLevelHashOld) revert MerkleTreeUpdateInvalidProof(); + side.value = currentLevelHashNew; + } + + bytes32 sibling = proof[i]; + currentLevelHashOld = fnHash( + isLeft ? currentLevelHashOld : sibling, + isLeft ? sibling : currentLevelHashOld + ); + currentLevelHashNew = fnHash( + isLeft ? currentLevelHashNew : sibling, + isLeft ? sibling : currentLevelHashNew + ); + } + return (currentLevelHashOld, currentLevelHashNew); + } + } + /** * @dev Tree's depth (set at initialization) */ diff --git a/docs/modules/ROOT/nav.adoc b/docs/modules/ROOT/nav.adoc index 15af8b40e..52f7e37b0 100644 --- a/docs/modules/ROOT/nav.adoc +++ b/docs/modules/ROOT/nav.adoc @@ -13,6 +13,7 @@ ** xref:erc721.adoc[ERC-721] ** xref:erc1155.adoc[ERC-1155] ** xref:erc4626.adoc[ERC-4626] +** xref:erc6909.adoc[ERC-6909] * xref:governance.adoc[Governance] diff --git a/docs/modules/ROOT/pages/access-control.adoc b/docs/modules/ROOT/pages/access-control.adoc index bef18ca11..57d26bc08 100644 --- a/docs/modules/ROOT/pages/access-control.adoc +++ b/docs/modules/ROOT/pages/access-control.adoc @@ -24,7 +24,7 @@ WARNING: Removing the owner altogether will mean that administrative tasks that Ownable is a simple and effective way to implement access control, but you should be mindful of the dangers associated with transferring the ownership to an incorrect account that can't interact with this contract anymore. An alternative to this problem is using xref:api:access.adoc#Ownable2Step[`Ownable2Step`]; a variant of Ownable that requires the new owner to explicitly accept the ownership transfer by calling xref:api:access.adoc#Ownable2Step-acceptOwnership--[`acceptOwnership`]. -Note that *a contract can also be the owner of another one*! This opens the door to using, for example, a https://gnosis-safe.io[Gnosis Safe], an https://aragon.org[Aragon DAO], or a totally custom contract that _you_ create. +Note that *a contract can also be the owner of another one*! This opens the door to using, for example, a https://safe.global[Gnosis Safe], an https://aragon.org[Aragon DAO], or a totally custom contract that _you_ create. In this way, you can use _composability_ to add additional layers of access control complexity to your contracts. Instead of having a single regular Ethereum account (Externally Owned Account, or EOA) as the owner, you could use a 2-of-3 multisig run by your project leads, for example. Prominent projects in the space, such as https://makerdao.com[MakerDAO], use systems similar to this one. diff --git a/docs/modules/ROOT/pages/crowdsales.adoc b/docs/modules/ROOT/pages/crowdsales.adoc deleted file mode 100644 index 37579211d..000000000 --- a/docs/modules/ROOT/pages/crowdsales.adoc +++ /dev/null @@ -1,11 +0,0 @@ -= Crowdsales - -All crowdsale-related contracts were removed from the OpenZeppelin Contracts library on the https://forum.openzeppelin.com/t/openzeppelin-contracts-v3-0-beta-release/2256[v3.0.0 release] due to both a decline in their usage and the complexity associated with migrating them to Solidity v0.6. - -They are however still available on the v2.5 release of OpenZeppelin Contracts, which you can install by running: - -```console -$ npm install @openzeppelin/contracts@v2.5 -``` - -Refer to the https://docs.openzeppelin.com/contracts/2.x/crowdsales[v2.x documentation] when working with them. diff --git a/docs/modules/ROOT/pages/drafts.adoc b/docs/modules/ROOT/pages/drafts.adoc deleted file mode 100644 index b2c1ae628..000000000 --- a/docs/modules/ROOT/pages/drafts.adoc +++ /dev/null @@ -1,19 +0,0 @@ -= Drafts - -All draft contracts were either moved into a different directory or removed from the OpenZeppelin Contracts library on the https://forum.openzeppelin.com/t/openzeppelin-contracts-v3-0-beta-release/2256[v3.0.0 release]. - -* `ERC20Migrator`: removed. -* xref:api:token/ERC20.adoc#ERC20Snapshot[`ERC20Snapshot`]: moved to `token/ERC20`. -* `ERC20Detailed` and `ERC1046`: removed. -* `TokenVesting`: removed. Pending a replacement that is being discussed in https://github.com/OpenZeppelin/openzeppelin-contracts/issues/1214[`#1214`]. -* xref:api:utils.adoc#Counters[`Counters`]: moved to xref:api:utils.adoc[`utils`]. -* xref:api:utils.adoc#Strings[`Strings`]: moved to xref:api:utils.adoc[`utils`]. -* xref:api:utils.adoc#SignedSafeMath[`SignedSafeMath`]: moved to xref:api:utils.adoc[`utils`]. - -Removed contracts are still available on the v2.5 release of OpenZeppelin Contracts, which you can install by running: - -```console -$ npm install @openzeppelin/contracts@v2.5 -``` - -Refer to the xref:2.x@contracts:api:drafts.adoc[v2.x documentation] when working with them. diff --git a/docs/modules/ROOT/pages/erc1155.adoc b/docs/modules/ROOT/pages/erc1155.adoc index 7f00f3ea4..2c31db8b8 100644 --- a/docs/modules/ROOT/pages/erc1155.adoc +++ b/docs/modules/ROOT/pages/erc1155.adoc @@ -106,7 +106,7 @@ A key difference when using xref:api:token/ERC1155.adoc#IERC1155-safeTransferFro ERC1155InvalidReceiver("
") ---- -This is a good thing! It means that the recipient contract has not registered itself as aware of the ERC-1155 protocol, so transfers to it are disabled to *prevent tokens from being locked forever*. As an example, https://etherscan.io/token/0xa74476443119A942dE498590Fe1f2454d7D4aC0d?a=0xa74476443119A942dE498590Fe1f2454d7D4aC0d[the Golem contract currently holds over 350k `GNT` tokens], worth multiple tens of thousands of dollars, and lacks methods to get them out of there. This has happened to virtually every ERC20-backed project, usually due to user error. +This is a good thing! It means that the recipient contract has not registered itself as aware of the ERC-1155 protocol, so transfers to it are disabled to *prevent tokens from being locked forever*. As an example, https://etherscan.io/token/0xa74476443119A942dE498590Fe1f2454d7D4aC0d?a=0xa74476443119A942dE498590Fe1f2454d7D4aC0d[the Golem contract currently holds over 350k `GNT` tokens], and lacks methods to get them out of there. This has happened to virtually every ERC20-backed project, usually due to user error. In order for our contract to receive ERC-1155 tokens we can inherit from the convenience contract xref:api:token/ERC1155.adoc#ERC1155Holder[`ERC1155Holder`] which handles the registering for us. However, we need to remember to implement functionality to allow tokens to be transferred out of our contract: diff --git a/docs/modules/ROOT/pages/erc20-supply.adoc b/docs/modules/ROOT/pages/erc20-supply.adoc index ae21e4a8a..273cb3252 100644 --- a/docs/modules/ROOT/pages/erc20-supply.adoc +++ b/docs/modules/ROOT/pages/erc20-supply.adoc @@ -68,4 +68,4 @@ include::api:example$ERC20WithAutoMinerReward.sol[] [[wrapping-up]] == Wrapping Up -We've seen how to implement a ERC-20 supply mechanism: internally through `_mint`. Hopefully this has helped you understand how to use OpenZeppelin Contracts and some of the design principles behind it, and you can apply them to your own smart contracts. +We've seen how to implement an ERC-20 supply mechanism: internally through `_mint`. Hopefully this has helped you understand how to use OpenZeppelin Contracts and some of the design principles behind it, and you can apply them to your own smart contracts. diff --git a/docs/modules/ROOT/pages/erc6909.adoc b/docs/modules/ROOT/pages/erc6909.adoc new file mode 100644 index 000000000..164ded8ed --- /dev/null +++ b/docs/modules/ROOT/pages/erc6909.adoc @@ -0,0 +1,47 @@ += ERC-6909 + +ERC-6909 is a draft EIP that draws on ERC-1155 learnings since it was published in 2018. The main goals of ERC-6909 is to decrease gas costs and complexity--this is mainly accomplished by removing batching and callbacks. + +TIP: To understand the inspiration for a multi token standard, see the xref:erc1155.adoc#multi-token-standard[multi token standard] section within the EIP-1155 docs. + +== Changes from ERC-1155 + +There are three main changes from ERC-1155 which are as follows: + +. The removal of batch operations. +. The removal of transfer callbacks. +. Granularization in approvals--approvals can be set globally (as operators) or as amounts per token (inspired by ERC20). + +== Constructing an ERC-6909 Token Contract + +We'll use ERC-6909 to track multiple items in a game, each having their own unique attributes. All item types will by minted to the deployer of the contract, which we can later transfer to players. We'll also use the xref:api:token/ERC6909.adoc#ERC6909Metadata[`ERC6909Metadata`] extension to add decimals to our fungible items (the vanilla ERC-6909 implementation does not have decimals). + +For simplicity, we will mint all items in the constructor--however, minting functionality could be added to the contract to mint on demand to players. + +TIP: For an overview of minting mechanisms, check out xref:erc20-supply.adoc[Creating ERC-20 Supply]. + +Here's what a contract for tokenized items might look like: + +[source,solidity] +---- +include::api:example$token/ERC6909/ERC6909GameItems.sol[] +---- + +Note that there is no content URI functionality in the base implementation, but the xref:api:token/ERC6909.adoc#ERC6909ContentURI[`ERC6909ContentURI`] extension adds it. Additionally, the base implementation does not track total supplies, but the xref:api:token/ERC6909.adoc#ERC6909TokenSupply[`ERC6909TokenSupply`] extension tracks the total supply of each token id. + +Once the contract is deployed, we will be able to query the deployer’s balance: +[source,javascript] +---- +> gameItems.balanceOf(deployerAddress, 3) +1000000000 +---- + +We can transfer items to player accounts: +[source,javascript] +---- +> gameItems.transfer(playerAddress, 2, 1) +> gameItems.balanceOf(playerAddress, 2) +1 +> gameItems.balanceOf(deployerAddress, 2) +0 +---- diff --git a/docs/modules/ROOT/pages/governance.adoc b/docs/modules/ROOT/pages/governance.adoc index 5f8e77555..c2b8218ff 100644 --- a/docs/modules/ROOT/pages/governance.adoc +++ b/docs/modules/ROOT/pages/governance.adoc @@ -20,7 +20,7 @@ The ERC-20 extension to keep track of votes and vote delegation is one such case === Governor & GovernorStorage -An OpenZeppelin Governor contract is not interface-compatible with Compound's GovernorAlpha or Bravo. Even though events are fully compatible, proposal lifecycle functions (creation, execution, etc.) have different signatures that are meant to optimize storage use. Other functions from GovernorAlpha and Bravo are likewise not available. It’s possible to opt in some Bravo-like behavior by inheriting from the GovernorStorage module. This module provides proposal enumerability and alternate versions of the `queue`, `execute` and `cancel` function that only take the proposal id. This module reduces the calldata needed by some operations in exchange for an increased the storage footprint. This might be a good trade-off for some L2 chains. It also provides primitives for indexer-free frontends. +An OpenZeppelin Governor contract is not interface-compatible with Compound's GovernorAlpha or Bravo. Even though events are fully compatible, proposal lifecycle functions (creation, execution, etc.) have different signatures that are meant to optimize storage use. Other functions from GovernorAlpha and Bravo are likewise not available. It’s possible to opt in some Bravo-like behavior by inheriting from the GovernorStorage module. This module provides proposal enumerability and alternate versions of the `queue`, `execute` and `cancel` function that only take the proposal id. This module reduces the calldata needed by some operations in exchange for an increased storage footprint. This might be a good trade-off for some L2 chains. It also provides primitives for indexer-free frontends. Note that even with the use of this module, one important difference with Compound's GovernorBravo is the way that `proposalId`s are calculated. Governor uses the hash of the proposal parameters with the purpose of keeping its data off-chain by event indexing, while the original Bravo implementation uses sequential `proposalId`s. @@ -52,7 +52,7 @@ If your project already has a live token that does not include ERC20Votes and is include::api:example$governance/MyTokenWrapped.sol[] ``` -NOTE: The only other source of voting power available in OpenZeppelin Contracts currently is xref:api:token/ERC721.adoc#ERC721Votes[`ERC721Votes`]. ERC-721 tokens that don't provide this functionality can be wrapped into a voting tokens using a combination of xref:api:token/ERC721.adoc#ERC721Votes[`ERC721Votes`] and xref:api:token/ERC721Wrapper.adoc#ERC721Wrapper[`ERC721Wrapper`]. +NOTE: The only other source of voting power available in OpenZeppelin Contracts currently is xref:api:token/ERC721.adoc#ERC721Votes[`ERC721Votes`]. ERC-721 tokens that don't provide this functionality can be wrapped into a voting tokens using a combination of xref:api:token/ERC721.adoc#ERC721Votes[`ERC721Votes`] and xref:api:token/ERC721.adoc#ERC721Wrapper[`ERC721Wrapper`]. NOTE: The internal clock used by the token to store voting balances will dictate the operating mode of the Governor contract attached to it. By default, block numbers are used. Since v4.9, developers can override the xref:api:interfaces.adoc#IERC6372[IERC6372] clock to use timestamps instead of block numbers. diff --git a/docs/modules/ROOT/pages/index.adoc b/docs/modules/ROOT/pages/index.adoc index 1ba449559..3c8e57ed3 100644 --- a/docs/modules/ROOT/pages/index.adoc +++ b/docs/modules/ROOT/pages/index.adoc @@ -63,7 +63,7 @@ The guides in the sidebar will teach about different concepts, and how to use th The xref:api:token/ERC20.adoc[full API] 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' development in the https://forum.openzeppelin.com[community forum]. -Finally, you may want to take a look at the https://blog.openzeppelin.com/guides/[guides on our blog], which cover several common use cases and good practices. The following articles provide great background reading, though please note, some of the referenced tools have changed as the tooling in the ecosystem continues to rapidly evolve. +The following articles provide great background reading, though please note, some of the referenced tools have changed as the tooling in the ecosystem continues to rapidly evolve. * https://blog.openzeppelin.com/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05[The Hitchhiker’s Guide to Smart Contracts in Ethereum] will help you get an overview of the various tools available for smart contract development, and help you set up your environment. * https://blog.openzeppelin.com/a-gentle-introduction-to-ethereum-programming-part-1-783cc7796094[A Gentle Introduction to Ethereum Programming, Part 1] provides very useful information on an introductory level, including many basic concepts from the Ethereum platform. diff --git a/docs/modules/ROOT/pages/utilities.adoc b/docs/modules/ROOT/pages/utilities.adoc index bb519907d..f6b22b025 100644 --- a/docs/modules/ROOT/pages/utilities.adoc +++ b/docs/modules/ROOT/pages/utilities.adoc @@ -12,7 +12,7 @@ At a high level, signatures are a set of cryptographic algorithms that allow for ==== Ethereum Signatures (secp256k1) -xref:api:utils.adoc#ECDSA[`ECDSA`] provides functions for recovering and managing Ethereum account ECDSA signatures. These are often generated via https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#sign[`web3.eth.sign`], and are a 65 byte array (of type `bytes` in Solidity) arranged the following way: `[[v (1)], [r (32)], [s (32)]]`. +xref:api:utils.adoc#ECDSA[`ECDSA`] provides functions for recovering and managing Ethereum account ECDSA signatures. These are often generated via https://web3js.readthedocs.io/en/v1.7.3/web3-eth.html#sign[`web3.eth.sign`], and form a 65-byte array (of type `bytes` in Solidity) arranged the following way: `[[v (1)], [r (32)], [s (32)]]`. The data signer can be recovered with xref:api:utils.adoc#ECDSA-recover-bytes32-bytes-[`ECDSA.recover`], and its address compared to verify the signature. Most wallets will hash the data to sign and add the prefix `\x19Ethereum Signed Message:\n`, so when attempting to recover the signer of an Ethereum signed message hash, you'll want to use xref:api:utils.adoc#MessageHashUtils-toEthSignedMessageHash-bytes32-[`toEthSignedMessageHash`]. @@ -197,7 +197,7 @@ The `Enumerable*` structures are similar to mappings in that they store and remo Building an on-chain Merkle Tree allows developers to keep track of the history of roots in a decentralized manner. For these cases, the xref:api:utils.adoc#MerkleTree[`MerkleTree`] includes a predefined structure with functions to manipulate the tree (e.g. pushing values or resetting the tree). -The Merkle Tree does not keep track of the roots purposely, so that developers can choose their tracking mechanism. Setting up and using a Merkle Tree in Solidity is as simple as follows: +The Merkle Tree does not keep track of the roots intentionally, so that developers can choose their tracking mechanism. Setting up and using a Merkle Tree in Solidity is as simple as follows: NOTE: Functions are exposed without access control for demonstration purposes @@ -243,7 +243,7 @@ function _hashFn(bytes32 a, bytes32 b) internal view returns(bytes32) { === Using a Heap -A https://en.wikipedia.org/wiki/Binary_heap[binary heap] is a data structure that always store the most important element at its peak and it can be used as a priority queue. +A https://en.wikipedia.org/wiki/Binary_heap[binary heap] is a data structure that always stores the most important element at its peak and it can be used as a priority queue. To define what is most important in a heap, these frequently take comparator functions that tell the binary heap whether a value has more relevance than another. @@ -358,7 +358,7 @@ This is especially useful for building URL-safe tokenURIs for both xref:api:toke Here is an example to send JSON Metadata through a Base64 Data URI using an ERC-721: -[source, solidity] +[source,solidity] ---- include::api:example$utilities/Base64NFT.sol[] ---- diff --git a/docs/modules/api/examples/access-control/AccessControlModified.sol b/docs/modules/api/examples/access-control/AccessControlModified.sol index bc944cabf..a08546a1e 100644 --- a/docs/modules/api/examples/access-control/AccessControlModified.sol +++ b/docs/modules/api/examples/access-control/AccessControlModified.sol @@ -5,10 +5,10 @@ pragma solidity ^0.8.20; import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol"; contract AccessControlModified is AccessControl { - error AccessControlNonRevokable(); + error AccessControlNonRevocable(); // Override the revokeRole function function revokeRole(bytes32, address) public pure override { - revert AccessControlNonRevokable(); + revert AccessControlNonRevocable(); } } diff --git a/docs/modules/api/examples/token/ERC6909/ERC6909GameItems.sol b/docs/modules/api/examples/token/ERC6909/ERC6909GameItems.sol new file mode 100644 index 000000000..8cdaca49c --- /dev/null +++ b/docs/modules/api/examples/token/ERC6909/ERC6909GameItems.sol @@ -0,0 +1,26 @@ +// SPDX-License-Identifier: MIT +pragma solidity ^0.8.20; + +import {ERC6909Metadata} from "@openzeppelin/contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol"; + +contract ERC6909GameItems is ERC6909Metadata { + uint256 public constant GOLD = 0; + uint256 public constant SILVER = 1; + uint256 public constant THORS_HAMMER = 2; + uint256 public constant SWORD = 3; + uint256 public constant SHIELD = 4; + + constructor() { + _setDecimals(GOLD, 18); + _setDecimals(SILVER, 18); + // Default decimals is 0 + _setDecimals(SWORD, 9); + _setDecimals(SHIELD, 9); + + _mint(msg.sender, GOLD, 10 ** 18); + _mint(msg.sender, SILVER, 10_000 ** 18); + _mint(msg.sender, THORS_HAMMER, 1); + _mint(msg.sender, SWORD, 10 ** 9); + _mint(msg.sender, SHIELD, 10 ** 9); + } +} diff --git a/docs/modules/api/nav.adoc b/docs/modules/api/nav.adoc index d9f67fd74..fcb227614 100644 --- a/docs/modules/api/nav.adoc +++ b/docs/modules/api/nav.adoc @@ -5,6 +5,7 @@ * xref:token/ERC20.adoc[ERC 20] * xref:token/ERC721.adoc[ERC 721] * xref:token/ERC1155.adoc[ERC 1155] +* xref:token/ERC6909.adoc[ERC 6909] * xref:finance.adoc[Finance] * xref:governance.adoc[Governance] * xref:interfaces.adoc[Interfaces] diff --git a/docs/modules/api/pages/access.adoc b/docs/modules/api/pages/access.adoc index 234edc012..5df51825f 100644 --- a/docs/modules/api/pages/access.adoc +++ b/docs/modules/api/pages/access.adoc @@ -356,9 +356,16 @@ This directory provides ways to restrict who can access the functions of a contr :transferOwnership: pass:normal[xref:#Ownable-transferOwnership-address-[`++transferOwnership++`]] :_transferOwnership: pass:normal[xref:#Ownable-_transferOwnership-address-[`++_transferOwnership++`]] +:constructor-address: pass:normal[xref:#Ownable-constructor-address-[`++constructor++`]] +:owner-: pass:normal[xref:#Ownable-owner--[`++owner++`]] +:_checkOwner-: pass:normal[xref:#Ownable-_checkOwner--[`++_checkOwner++`]] +:renounceOwnership-: pass:normal[xref:#Ownable-renounceOwnership--[`++renounceOwnership++`]] +:transferOwnership-address: pass:normal[xref:#Ownable-transferOwnership-address-[`++transferOwnership++`]] +:_transferOwnership-address: pass:normal[xref:#Ownable-_transferOwnership-address-[`++_transferOwnership++`]] + [.contract] [[Ownable]] -=== `++Ownable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/Ownable.sol[{github-icon},role=heading-link] +=== `++Ownable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/Ownable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -479,9 +486,14 @@ The owner is not a valid owner account. (eg. `address(0)`) :_transferOwnership: pass:normal[xref:#Ownable2Step-_transferOwnership-address-[`++_transferOwnership++`]] :acceptOwnership: pass:normal[xref:#Ownable2Step-acceptOwnership--[`++acceptOwnership++`]] +:pendingOwner-: pass:normal[xref:#Ownable2Step-pendingOwner--[`++pendingOwner++`]] +:transferOwnership-address: pass:normal[xref:#Ownable2Step-transferOwnership-address-[`++transferOwnership++`]] +:_transferOwnership-address: pass:normal[xref:#Ownable2Step-_transferOwnership-address-[`++_transferOwnership++`]] +:acceptOwnership-: pass:normal[xref:#Ownable2Step-acceptOwnership--[`++acceptOwnership++`]] + [.contract] [[Ownable2Step]] -=== `++Ownable2Step++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/Ownable2Step.sol[{github-icon},role=heading-link] +=== `++Ownable2Step++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/Ownable2Step.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -585,9 +597,15 @@ The new owner accepts the ownership transfer. :revokeRole: pass:normal[xref:#IAccessControl-revokeRole-bytes32-address-[`++revokeRole++`]] :renounceRole: pass:normal[xref:#IAccessControl-renounceRole-bytes32-address-[`++renounceRole++`]] +:hasRole-bytes32-address: pass:normal[xref:#IAccessControl-hasRole-bytes32-address-[`++hasRole++`]] +:getRoleAdmin-bytes32: pass:normal[xref:#IAccessControl-getRoleAdmin-bytes32-[`++getRoleAdmin++`]] +:grantRole-bytes32-address: pass:normal[xref:#IAccessControl-grantRole-bytes32-address-[`++grantRole++`]] +:revokeRole-bytes32-address: pass:normal[xref:#IAccessControl-revokeRole-bytes32-address-[`++revokeRole++`]] +:renounceRole-bytes32-address: pass:normal[xref:#IAccessControl-renounceRole-bytes32-address-[`++renounceRole++`]] + [.contract] [[IAccessControl]] -=== `++IAccessControl++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/IAccessControl.sol[{github-icon},role=heading-link] +=== `++IAccessControl++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/IAccessControl.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -688,7 +706,7 @@ Requirements: 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. +{RoleAdminChanged} not being emitted to signal this. [.contract-item] [[IAccessControl-RoleGranted-bytes32-address-address-]] @@ -738,9 +756,22 @@ NOTE: Don't confuse with {AccessControlUnauthorizedAccount}. :_grantRole: pass:normal[xref:#AccessControl-_grantRole-bytes32-address-[`++_grantRole++`]] :_revokeRole: pass:normal[xref:#AccessControl-_revokeRole-bytes32-address-[`++_revokeRole++`]] +:supportsInterface-bytes4: pass:normal[xref:#AccessControl-supportsInterface-bytes4-[`++supportsInterface++`]] +:hasRole-bytes32-address: pass:normal[xref:#AccessControl-hasRole-bytes32-address-[`++hasRole++`]] +:_checkRole-bytes32: pass:normal[xref:#AccessControl-_checkRole-bytes32-[`++_checkRole++`]] +:_checkRole-bytes32-address: pass:normal[xref:#AccessControl-_checkRole-bytes32-address-[`++_checkRole++`]] +:getRoleAdmin-bytes32: pass:normal[xref:#AccessControl-getRoleAdmin-bytes32-[`++getRoleAdmin++`]] +:grantRole-bytes32-address: pass:normal[xref:#AccessControl-grantRole-bytes32-address-[`++grantRole++`]] +:revokeRole-bytes32-address: pass:normal[xref:#AccessControl-revokeRole-bytes32-address-[`++revokeRole++`]] +:renounceRole-bytes32-address: pass:normal[xref:#AccessControl-renounceRole-bytes32-address-[`++renounceRole++`]] +:_setRoleAdmin-bytes32-bytes32: pass:normal[xref:#AccessControl-_setRoleAdmin-bytes32-bytes32-[`++_setRoleAdmin++`]] +:_grantRole-bytes32-address: pass:normal[xref:#AccessControl-_grantRole-bytes32-address-[`++_grantRole++`]] +:_revokeRole-bytes32-address: pass:normal[xref:#AccessControl-_revokeRole-bytes32-address-[`++_revokeRole++`]] +:DEFAULT_ADMIN_ROLE-bytes32: pass:normal[xref:#AccessControl-DEFAULT_ADMIN_ROLE-bytes32[`++DEFAULT_ADMIN_ROLE++`]] + [.contract] [[AccessControl]] -=== `++AccessControl++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/AccessControl.sol[{github-icon},role=heading-link] +=== `++AccessControl++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/AccessControl.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -965,7 +996,7 @@ May emit a {RoleGranted} event. [[AccessControl-_revokeRole-bytes32-address-]] ==== `[.contract-item-name]#++_revokeRole++#++(bytes32 role, address account) → bool++` [.item-kind]#internal# -Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked. +Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked. Internal function without access restriction. @@ -980,9 +1011,12 @@ May emit a {RoleRevoked} event. :getRoleMember: pass:normal[xref:#IAccessControlEnumerable-getRoleMember-bytes32-uint256-[`++getRoleMember++`]] :getRoleMemberCount: pass:normal[xref:#IAccessControlEnumerable-getRoleMemberCount-bytes32-[`++getRoleMemberCount++`]] +:getRoleMember-bytes32-uint256: pass:normal[xref:#IAccessControlEnumerable-getRoleMember-bytes32-uint256-[`++getRoleMember++`]] +:getRoleMemberCount-bytes32: pass:normal[xref:#IAccessControlEnumerable-getRoleMemberCount-bytes32-[`++getRoleMemberCount++`]] + [.contract] [[IAccessControlEnumerable]] -=== `++IAccessControlEnumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/extensions/IAccessControlEnumerable.sol[{github-icon},role=heading-link] +=== `++IAccessControlEnumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/extensions/IAccessControlEnumerable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1059,9 +1093,16 @@ together with {getRoleMember} to enumerate all bearers of a role. :_grantRole: pass:normal[xref:#AccessControlEnumerable-_grantRole-bytes32-address-[`++_grantRole++`]] :_revokeRole: pass:normal[xref:#AccessControlEnumerable-_revokeRole-bytes32-address-[`++_revokeRole++`]] +:supportsInterface-bytes4: pass:normal[xref:#AccessControlEnumerable-supportsInterface-bytes4-[`++supportsInterface++`]] +:getRoleMember-bytes32-uint256: pass:normal[xref:#AccessControlEnumerable-getRoleMember-bytes32-uint256-[`++getRoleMember++`]] +:getRoleMemberCount-bytes32: pass:normal[xref:#AccessControlEnumerable-getRoleMemberCount-bytes32-[`++getRoleMemberCount++`]] +:getRoleMembers-bytes32: pass:normal[xref:#AccessControlEnumerable-getRoleMembers-bytes32-[`++getRoleMembers++`]] +:_grantRole-bytes32-address: pass:normal[xref:#AccessControlEnumerable-_grantRole-bytes32-address-[`++_grantRole++`]] +:_revokeRole-bytes32-address: pass:normal[xref:#AccessControlEnumerable-_revokeRole-bytes32-address-[`++_revokeRole++`]] + [.contract] [[AccessControlEnumerable]] -=== `++AccessControlEnumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/extensions/AccessControlEnumerable.sol[{github-icon},role=heading-link] +=== `++AccessControlEnumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/extensions/AccessControlEnumerable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1222,9 +1263,20 @@ Overload {AccessControl-_revokeRole} to track enumerable memberships :rollbackDefaultAdminDelay: pass:normal[xref:#IAccessControlDefaultAdminRules-rollbackDefaultAdminDelay--[`++rollbackDefaultAdminDelay++`]] :defaultAdminDelayIncreaseWait: pass:normal[xref:#IAccessControlDefaultAdminRules-defaultAdminDelayIncreaseWait--[`++defaultAdminDelayIncreaseWait++`]] +:defaultAdmin-: pass:normal[xref:#IAccessControlDefaultAdminRules-defaultAdmin--[`++defaultAdmin++`]] +:pendingDefaultAdmin-: pass:normal[xref:#IAccessControlDefaultAdminRules-pendingDefaultAdmin--[`++pendingDefaultAdmin++`]] +:defaultAdminDelay-: pass:normal[xref:#IAccessControlDefaultAdminRules-defaultAdminDelay--[`++defaultAdminDelay++`]] +:pendingDefaultAdminDelay-: pass:normal[xref:#IAccessControlDefaultAdminRules-pendingDefaultAdminDelay--[`++pendingDefaultAdminDelay++`]] +:beginDefaultAdminTransfer-address: pass:normal[xref:#IAccessControlDefaultAdminRules-beginDefaultAdminTransfer-address-[`++beginDefaultAdminTransfer++`]] +:cancelDefaultAdminTransfer-: pass:normal[xref:#IAccessControlDefaultAdminRules-cancelDefaultAdminTransfer--[`++cancelDefaultAdminTransfer++`]] +:acceptDefaultAdminTransfer-: pass:normal[xref:#IAccessControlDefaultAdminRules-acceptDefaultAdminTransfer--[`++acceptDefaultAdminTransfer++`]] +:changeDefaultAdminDelay-uint48: pass:normal[xref:#IAccessControlDefaultAdminRules-changeDefaultAdminDelay-uint48-[`++changeDefaultAdminDelay++`]] +:rollbackDefaultAdminDelay-: pass:normal[xref:#IAccessControlDefaultAdminRules-rollbackDefaultAdminDelay--[`++rollbackDefaultAdminDelay++`]] +:defaultAdminDelayIncreaseWait-: pass:normal[xref:#IAccessControlDefaultAdminRules-defaultAdminDelayIncreaseWait--[`++defaultAdminDelayIncreaseWait++`]] + [.contract] [[IAccessControlDefaultAdminRules]] -=== `++IAccessControlDefaultAdminRules++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/extensions/IAccessControlDefaultAdminRules.sol[{github-icon},role=heading-link] +=== `++IAccessControlDefaultAdminRules++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/extensions/IAccessControlDefaultAdminRules.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1511,9 +1563,35 @@ NOTE: `schedule` can be 0 indicating there's no transfer scheduled. :_rollbackDefaultAdminDelay: pass:normal[xref:#AccessControlDefaultAdminRules-_rollbackDefaultAdminDelay--[`++_rollbackDefaultAdminDelay++`]] :_delayChangeWait: pass:normal[xref:#AccessControlDefaultAdminRules-_delayChangeWait-uint48-[`++_delayChangeWait++`]] +:constructor-uint48-address: pass:normal[xref:#AccessControlDefaultAdminRules-constructor-uint48-address-[`++constructor++`]] +:supportsInterface-bytes4: pass:normal[xref:#AccessControlDefaultAdminRules-supportsInterface-bytes4-[`++supportsInterface++`]] +:owner-: pass:normal[xref:#AccessControlDefaultAdminRules-owner--[`++owner++`]] +:grantRole-bytes32-address: pass:normal[xref:#AccessControlDefaultAdminRules-grantRole-bytes32-address-[`++grantRole++`]] +:revokeRole-bytes32-address: pass:normal[xref:#AccessControlDefaultAdminRules-revokeRole-bytes32-address-[`++revokeRole++`]] +:renounceRole-bytes32-address: pass:normal[xref:#AccessControlDefaultAdminRules-renounceRole-bytes32-address-[`++renounceRole++`]] +:_grantRole-bytes32-address: pass:normal[xref:#AccessControlDefaultAdminRules-_grantRole-bytes32-address-[`++_grantRole++`]] +:_revokeRole-bytes32-address: pass:normal[xref:#AccessControlDefaultAdminRules-_revokeRole-bytes32-address-[`++_revokeRole++`]] +:_setRoleAdmin-bytes32-bytes32: pass:normal[xref:#AccessControlDefaultAdminRules-_setRoleAdmin-bytes32-bytes32-[`++_setRoleAdmin++`]] +:defaultAdmin-: pass:normal[xref:#AccessControlDefaultAdminRules-defaultAdmin--[`++defaultAdmin++`]] +:pendingDefaultAdmin-: pass:normal[xref:#AccessControlDefaultAdminRules-pendingDefaultAdmin--[`++pendingDefaultAdmin++`]] +:defaultAdminDelay-: pass:normal[xref:#AccessControlDefaultAdminRules-defaultAdminDelay--[`++defaultAdminDelay++`]] +:pendingDefaultAdminDelay-: pass:normal[xref:#AccessControlDefaultAdminRules-pendingDefaultAdminDelay--[`++pendingDefaultAdminDelay++`]] +:defaultAdminDelayIncreaseWait-: pass:normal[xref:#AccessControlDefaultAdminRules-defaultAdminDelayIncreaseWait--[`++defaultAdminDelayIncreaseWait++`]] +:beginDefaultAdminTransfer-address: pass:normal[xref:#AccessControlDefaultAdminRules-beginDefaultAdminTransfer-address-[`++beginDefaultAdminTransfer++`]] +:_beginDefaultAdminTransfer-address: pass:normal[xref:#AccessControlDefaultAdminRules-_beginDefaultAdminTransfer-address-[`++_beginDefaultAdminTransfer++`]] +:cancelDefaultAdminTransfer-: pass:normal[xref:#AccessControlDefaultAdminRules-cancelDefaultAdminTransfer--[`++cancelDefaultAdminTransfer++`]] +:_cancelDefaultAdminTransfer-: pass:normal[xref:#AccessControlDefaultAdminRules-_cancelDefaultAdminTransfer--[`++_cancelDefaultAdminTransfer++`]] +:acceptDefaultAdminTransfer-: pass:normal[xref:#AccessControlDefaultAdminRules-acceptDefaultAdminTransfer--[`++acceptDefaultAdminTransfer++`]] +:_acceptDefaultAdminTransfer-: pass:normal[xref:#AccessControlDefaultAdminRules-_acceptDefaultAdminTransfer--[`++_acceptDefaultAdminTransfer++`]] +:changeDefaultAdminDelay-uint48: pass:normal[xref:#AccessControlDefaultAdminRules-changeDefaultAdminDelay-uint48-[`++changeDefaultAdminDelay++`]] +:_changeDefaultAdminDelay-uint48: pass:normal[xref:#AccessControlDefaultAdminRules-_changeDefaultAdminDelay-uint48-[`++_changeDefaultAdminDelay++`]] +:rollbackDefaultAdminDelay-: pass:normal[xref:#AccessControlDefaultAdminRules-rollbackDefaultAdminDelay--[`++rollbackDefaultAdminDelay++`]] +:_rollbackDefaultAdminDelay-: pass:normal[xref:#AccessControlDefaultAdminRules-_rollbackDefaultAdminDelay--[`++_rollbackDefaultAdminDelay++`]] +:_delayChangeWait-uint48: pass:normal[xref:#AccessControlDefaultAdminRules-_delayChangeWait-uint48-[`++_delayChangeWait++`]] + [.contract] [[AccessControlDefaultAdminRules]] -=== `++AccessControlDefaultAdminRules++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/extensions/AccessControlDefaultAdminRules.sol[{github-icon},role=heading-link] +=== `++AccessControlDefaultAdminRules++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/extensions/AccessControlDefaultAdminRules.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1932,9 +2010,11 @@ See {defaultAdminDelayIncreaseWait}. :canCall: pass:normal[xref:#IAuthority-canCall-address-address-bytes4-[`++canCall++`]] +:canCall-address-address-bytes4: pass:normal[xref:#IAuthority-canCall-address-address-bytes4-[`++canCall++`]] + [.contract] [[IAuthority]] -=== `++IAuthority++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/manager/IAuthority.sol[{github-icon},role=heading-link] +=== `++IAuthority++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/manager/IAuthority.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2009,9 +2089,39 @@ Returns true if the caller can invoke on a target the function identified by a f :hashOperation: pass:normal[xref:#IAccessManager-hashOperation-address-address-bytes-[`++hashOperation++`]] :updateAuthority: pass:normal[xref:#IAccessManager-updateAuthority-address-address-[`++updateAuthority++`]] +:canCall-address-address-bytes4: pass:normal[xref:#IAccessManager-canCall-address-address-bytes4-[`++canCall++`]] +:expiration-: pass:normal[xref:#IAccessManager-expiration--[`++expiration++`]] +:minSetback-: pass:normal[xref:#IAccessManager-minSetback--[`++minSetback++`]] +:isTargetClosed-address: pass:normal[xref:#IAccessManager-isTargetClosed-address-[`++isTargetClosed++`]] +:getTargetFunctionRole-address-bytes4: pass:normal[xref:#IAccessManager-getTargetFunctionRole-address-bytes4-[`++getTargetFunctionRole++`]] +:getTargetAdminDelay-address: pass:normal[xref:#IAccessManager-getTargetAdminDelay-address-[`++getTargetAdminDelay++`]] +:getRoleAdmin-uint64: pass:normal[xref:#IAccessManager-getRoleAdmin-uint64-[`++getRoleAdmin++`]] +:getRoleGuardian-uint64: pass:normal[xref:#IAccessManager-getRoleGuardian-uint64-[`++getRoleGuardian++`]] +:getRoleGrantDelay-uint64: pass:normal[xref:#IAccessManager-getRoleGrantDelay-uint64-[`++getRoleGrantDelay++`]] +:getAccess-uint64-address: pass:normal[xref:#IAccessManager-getAccess-uint64-address-[`++getAccess++`]] +:hasRole-uint64-address: pass:normal[xref:#IAccessManager-hasRole-uint64-address-[`++hasRole++`]] +:labelRole-uint64-string: pass:normal[xref:#IAccessManager-labelRole-uint64-string-[`++labelRole++`]] +:grantRole-uint64-address-uint32: pass:normal[xref:#IAccessManager-grantRole-uint64-address-uint32-[`++grantRole++`]] +:revokeRole-uint64-address: pass:normal[xref:#IAccessManager-revokeRole-uint64-address-[`++revokeRole++`]] +:renounceRole-uint64-address: pass:normal[xref:#IAccessManager-renounceRole-uint64-address-[`++renounceRole++`]] +:setRoleAdmin-uint64-uint64: pass:normal[xref:#IAccessManager-setRoleAdmin-uint64-uint64-[`++setRoleAdmin++`]] +:setRoleGuardian-uint64-uint64: pass:normal[xref:#IAccessManager-setRoleGuardian-uint64-uint64-[`++setRoleGuardian++`]] +:setGrantDelay-uint64-uint32: pass:normal[xref:#IAccessManager-setGrantDelay-uint64-uint32-[`++setGrantDelay++`]] +:setTargetFunctionRole-address-bytes4---uint64: pass:normal[xref:#IAccessManager-setTargetFunctionRole-address-bytes4---uint64-[`++setTargetFunctionRole++`]] +:setTargetAdminDelay-address-uint32: pass:normal[xref:#IAccessManager-setTargetAdminDelay-address-uint32-[`++setTargetAdminDelay++`]] +:setTargetClosed-address-bool: pass:normal[xref:#IAccessManager-setTargetClosed-address-bool-[`++setTargetClosed++`]] +:getSchedule-bytes32: pass:normal[xref:#IAccessManager-getSchedule-bytes32-[`++getSchedule++`]] +:getNonce-bytes32: pass:normal[xref:#IAccessManager-getNonce-bytes32-[`++getNonce++`]] +:schedule-address-bytes-uint48: pass:normal[xref:#IAccessManager-schedule-address-bytes-uint48-[`++schedule++`]] +:execute-address-bytes: pass:normal[xref:#IAccessManager-execute-address-bytes-[`++execute++`]] +:cancel-address-address-bytes: pass:normal[xref:#IAccessManager-cancel-address-address-bytes-[`++cancel++`]] +:consumeScheduledOp-address-bytes: pass:normal[xref:#IAccessManager-consumeScheduledOp-address-bytes-[`++consumeScheduledOp++`]] +:hashOperation-address-address-bytes: pass:normal[xref:#IAccessManager-hashOperation-address-address-bytes-[`++hashOperation++`]] +:updateAuthority-address-address: pass:normal[xref:#IAccessManager-updateAuthority-address-address-[`++updateAuthority++`]] + [.contract] [[IAccessManager]] -=== `++IAccessManager++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/manager/IAccessManager.sol[{github-icon},role=heading-link] +=== `++IAccessManager++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/manager/IAccessManager.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2583,9 +2693,51 @@ Admin delay for a given `target` will be updated to `delay` when `since` is reac :hashOperation: pass:normal[xref:#AccessManager-hashOperation-address-address-bytes-[`++hashOperation++`]] :updateAuthority: pass:normal[xref:#AccessManager-updateAuthority-address-address-[`++updateAuthority++`]] +:constructor-address: pass:normal[xref:#AccessManager-constructor-address-[`++constructor++`]] +:canCall-address-address-bytes4: pass:normal[xref:#AccessManager-canCall-address-address-bytes4-[`++canCall++`]] +:expiration-: pass:normal[xref:#AccessManager-expiration--[`++expiration++`]] +:minSetback-: pass:normal[xref:#AccessManager-minSetback--[`++minSetback++`]] +:isTargetClosed-address: pass:normal[xref:#AccessManager-isTargetClosed-address-[`++isTargetClosed++`]] +:getTargetFunctionRole-address-bytes4: pass:normal[xref:#AccessManager-getTargetFunctionRole-address-bytes4-[`++getTargetFunctionRole++`]] +:getTargetAdminDelay-address: pass:normal[xref:#AccessManager-getTargetAdminDelay-address-[`++getTargetAdminDelay++`]] +:getRoleAdmin-uint64: pass:normal[xref:#AccessManager-getRoleAdmin-uint64-[`++getRoleAdmin++`]] +:getRoleGuardian-uint64: pass:normal[xref:#AccessManager-getRoleGuardian-uint64-[`++getRoleGuardian++`]] +:getRoleGrantDelay-uint64: pass:normal[xref:#AccessManager-getRoleGrantDelay-uint64-[`++getRoleGrantDelay++`]] +:getAccess-uint64-address: pass:normal[xref:#AccessManager-getAccess-uint64-address-[`++getAccess++`]] +:hasRole-uint64-address: pass:normal[xref:#AccessManager-hasRole-uint64-address-[`++hasRole++`]] +:labelRole-uint64-string: pass:normal[xref:#AccessManager-labelRole-uint64-string-[`++labelRole++`]] +:grantRole-uint64-address-uint32: pass:normal[xref:#AccessManager-grantRole-uint64-address-uint32-[`++grantRole++`]] +:revokeRole-uint64-address: pass:normal[xref:#AccessManager-revokeRole-uint64-address-[`++revokeRole++`]] +:renounceRole-uint64-address: pass:normal[xref:#AccessManager-renounceRole-uint64-address-[`++renounceRole++`]] +:setRoleAdmin-uint64-uint64: pass:normal[xref:#AccessManager-setRoleAdmin-uint64-uint64-[`++setRoleAdmin++`]] +:setRoleGuardian-uint64-uint64: pass:normal[xref:#AccessManager-setRoleGuardian-uint64-uint64-[`++setRoleGuardian++`]] +:setGrantDelay-uint64-uint32: pass:normal[xref:#AccessManager-setGrantDelay-uint64-uint32-[`++setGrantDelay++`]] +:_grantRole-uint64-address-uint32-uint32: pass:normal[xref:#AccessManager-_grantRole-uint64-address-uint32-uint32-[`++_grantRole++`]] +:_revokeRole-uint64-address: pass:normal[xref:#AccessManager-_revokeRole-uint64-address-[`++_revokeRole++`]] +:_setRoleAdmin-uint64-uint64: pass:normal[xref:#AccessManager-_setRoleAdmin-uint64-uint64-[`++_setRoleAdmin++`]] +:_setRoleGuardian-uint64-uint64: pass:normal[xref:#AccessManager-_setRoleGuardian-uint64-uint64-[`++_setRoleGuardian++`]] +:_setGrantDelay-uint64-uint32: pass:normal[xref:#AccessManager-_setGrantDelay-uint64-uint32-[`++_setGrantDelay++`]] +:setTargetFunctionRole-address-bytes4---uint64: pass:normal[xref:#AccessManager-setTargetFunctionRole-address-bytes4---uint64-[`++setTargetFunctionRole++`]] +:_setTargetFunctionRole-address-bytes4-uint64: pass:normal[xref:#AccessManager-_setTargetFunctionRole-address-bytes4-uint64-[`++_setTargetFunctionRole++`]] +:setTargetAdminDelay-address-uint32: pass:normal[xref:#AccessManager-setTargetAdminDelay-address-uint32-[`++setTargetAdminDelay++`]] +:_setTargetAdminDelay-address-uint32: pass:normal[xref:#AccessManager-_setTargetAdminDelay-address-uint32-[`++_setTargetAdminDelay++`]] +:setTargetClosed-address-bool: pass:normal[xref:#AccessManager-setTargetClosed-address-bool-[`++setTargetClosed++`]] +:_setTargetClosed-address-bool: pass:normal[xref:#AccessManager-_setTargetClosed-address-bool-[`++_setTargetClosed++`]] +:getSchedule-bytes32: pass:normal[xref:#AccessManager-getSchedule-bytes32-[`++getSchedule++`]] +:getNonce-bytes32: pass:normal[xref:#AccessManager-getNonce-bytes32-[`++getNonce++`]] +:schedule-address-bytes-uint48: pass:normal[xref:#AccessManager-schedule-address-bytes-uint48-[`++schedule++`]] +:execute-address-bytes: pass:normal[xref:#AccessManager-execute-address-bytes-[`++execute++`]] +:cancel-address-address-bytes: pass:normal[xref:#AccessManager-cancel-address-address-bytes-[`++cancel++`]] +:consumeScheduledOp-address-bytes: pass:normal[xref:#AccessManager-consumeScheduledOp-address-bytes-[`++consumeScheduledOp++`]] +:_consumeScheduledOp-bytes32: pass:normal[xref:#AccessManager-_consumeScheduledOp-bytes32-[`++_consumeScheduledOp++`]] +:hashOperation-address-address-bytes: pass:normal[xref:#AccessManager-hashOperation-address-address-bytes-[`++hashOperation++`]] +:updateAuthority-address-address: pass:normal[xref:#AccessManager-updateAuthority-address-address-[`++updateAuthority++`]] +:ADMIN_ROLE-uint64: pass:normal[xref:#AccessManager-ADMIN_ROLE-uint64[`++ADMIN_ROLE++`]] +:PUBLIC_ROLE-uint64: pass:normal[xref:#AccessManager-PUBLIC_ROLE-uint64[`++PUBLIC_ROLE++`]] + [.contract] [[AccessManager]] -=== `++AccessManager++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/manager/AccessManager.sol[{github-icon},role=heading-link] +=== `++AccessManager++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/manager/AccessManager.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3184,9 +3336,13 @@ The identifier of the public role. Automatically granted to all addresses with n :setAuthority: pass:normal[xref:#IAccessManaged-setAuthority-address-[`++setAuthority++`]] :isConsumingScheduledOp: pass:normal[xref:#IAccessManaged-isConsumingScheduledOp--[`++isConsumingScheduledOp++`]] +:authority-: pass:normal[xref:#IAccessManaged-authority--[`++authority++`]] +:setAuthority-address: pass:normal[xref:#IAccessManaged-setAuthority-address-[`++setAuthority++`]] +:isConsumingScheduledOp-: pass:normal[xref:#IAccessManaged-isConsumingScheduledOp--[`++isConsumingScheduledOp++`]] + [.contract] [[IAccessManaged]] -=== `++IAccessManaged++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/manager/IAccessManaged.sol[{github-icon},role=heading-link] +=== `++IAccessManaged++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/manager/IAccessManaged.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3264,9 +3420,16 @@ Authority that manages this contract was updated. :_setAuthority: pass:normal[xref:#AccessManaged-_setAuthority-address-[`++_setAuthority++`]] :_checkCanCall: pass:normal[xref:#AccessManaged-_checkCanCall-address-bytes-[`++_checkCanCall++`]] +:constructor-address: pass:normal[xref:#AccessManaged-constructor-address-[`++constructor++`]] +:authority-: pass:normal[xref:#AccessManaged-authority--[`++authority++`]] +:setAuthority-address: pass:normal[xref:#AccessManaged-setAuthority-address-[`++setAuthority++`]] +:isConsumingScheduledOp-: pass:normal[xref:#AccessManaged-isConsumingScheduledOp--[`++isConsumingScheduledOp++`]] +:_setAuthority-address: pass:normal[xref:#AccessManaged-_setAuthority-address-[`++_setAuthority++`]] +:_checkCanCall-address-bytes: pass:normal[xref:#AccessManaged-_checkCanCall-address-bytes-[`++_checkCanCall++`]] + [.contract] [[AccessManaged]] -=== `++AccessManaged++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/manager/AccessManaged.sol[{github-icon},role=heading-link] +=== `++AccessManaged++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/manager/AccessManaged.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3392,9 +3555,11 @@ is less than 4 bytes long. :canCallWithDelay: pass:normal[xref:#AuthorityUtils-canCallWithDelay-address-address-address-bytes4-[`++canCallWithDelay++`]] +:canCallWithDelay-address-address-address-bytes4: pass:normal[xref:#AuthorityUtils-canCallWithDelay-address-address-address-bytes4-[`++canCallWithDelay++`]] + [.contract] [[AuthorityUtils]] -=== `++AuthorityUtils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/access/manager/AuthorityUtils.sol[{github-icon},role=heading-link] +=== `++AuthorityUtils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/access/manager/AuthorityUtils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity diff --git a/docs/modules/api/pages/account.adoc b/docs/modules/api/pages/account.adoc index c5c7dcf65..5a96f4271 100644 --- a/docs/modules/api/pages/account.adoc +++ b/docs/modules/api/pages/account.adoc @@ -4,7 +4,7 @@ :xref-ERC4337Utils-packValidationData-bool-uint48-uint48-: xref:account.adoc#ERC4337Utils-packValidationData-bool-uint48-uint48- :xref-ERC4337Utils-combineValidationData-uint256-uint256-: xref:account.adoc#ERC4337Utils-combineValidationData-uint256-uint256- :xref-ERC4337Utils-getValidationData-uint256-: xref:account.adoc#ERC4337Utils-getValidationData-uint256- -:xref-ERC4337Utils-hash-struct-PackedUserOperation-address-uint256-: xref:account.adoc#ERC4337Utils-hash-struct-PackedUserOperation-address-uint256- +:xref-ERC4337Utils-hash-struct-PackedUserOperation-address-: xref:account.adoc#ERC4337Utils-hash-struct-PackedUserOperation-address- :xref-ERC4337Utils-factory-struct-PackedUserOperation-: xref:account.adoc#ERC4337Utils-factory-struct-PackedUserOperation- :xref-ERC4337Utils-factoryData-struct-PackedUserOperation-: xref:account.adoc#ERC4337Utils-factoryData-struct-PackedUserOperation- :xref-ERC4337Utils-verificationGasLimit-struct-PackedUserOperation-: xref:account.adoc#ERC4337Utils-verificationGasLimit-struct-PackedUserOperation- @@ -16,6 +16,8 @@ :xref-ERC4337Utils-paymasterVerificationGasLimit-struct-PackedUserOperation-: xref:account.adoc#ERC4337Utils-paymasterVerificationGasLimit-struct-PackedUserOperation- :xref-ERC4337Utils-paymasterPostOpGasLimit-struct-PackedUserOperation-: xref:account.adoc#ERC4337Utils-paymasterPostOpGasLimit-struct-PackedUserOperation- :xref-ERC4337Utils-paymasterData-struct-PackedUserOperation-: xref:account.adoc#ERC4337Utils-paymasterData-struct-PackedUserOperation- +:xref-ERC4337Utils-ENTRYPOINT_V07-contract-IEntryPoint: xref:account.adoc#ERC4337Utils-ENTRYPOINT_V07-contract-IEntryPoint +:xref-ERC4337Utils-ENTRYPOINT_V08-contract-IEntryPoint: xref:account.adoc#ERC4337Utils-ENTRYPOINT_V08-contract-IEntryPoint :xref-ERC4337Utils-SIG_VALIDATION_SUCCESS-uint256: xref:account.adoc#ERC4337Utils-SIG_VALIDATION_SUCCESS-uint256 :xref-ERC4337Utils-SIG_VALIDATION_FAILED-uint256: xref:account.adoc#ERC4337Utils-SIG_VALIDATION_FAILED-uint256 :PackedUserOperation: pass:normal[xref:interfaces.adoc#PackedUserOperation[`PackedUserOperation`]] @@ -64,6 +66,8 @@ This directory includes contracts to build accounts for ERC-4337. == Utilities +:ENTRYPOINT_V07: pass:normal[xref:#ERC4337Utils-ENTRYPOINT_V07-contract-IEntryPoint[`++ENTRYPOINT_V07++`]] +:ENTRYPOINT_V08: pass:normal[xref:#ERC4337Utils-ENTRYPOINT_V08-contract-IEntryPoint[`++ENTRYPOINT_V08++`]] :SIG_VALIDATION_SUCCESS: pass:normal[xref:#ERC4337Utils-SIG_VALIDATION_SUCCESS-uint256[`++SIG_VALIDATION_SUCCESS++`]] :SIG_VALIDATION_FAILED: pass:normal[xref:#ERC4337Utils-SIG_VALIDATION_FAILED-uint256[`++SIG_VALIDATION_FAILED++`]] :parseValidationData: pass:normal[xref:#ERC4337Utils-parseValidationData-uint256-[`++parseValidationData++`]] @@ -71,7 +75,7 @@ This directory includes contracts to build accounts for ERC-4337. :packValidationData: pass:normal[xref:#ERC4337Utils-packValidationData-bool-uint48-uint48-[`++packValidationData++`]] :combineValidationData: pass:normal[xref:#ERC4337Utils-combineValidationData-uint256-uint256-[`++combineValidationData++`]] :getValidationData: pass:normal[xref:#ERC4337Utils-getValidationData-uint256-[`++getValidationData++`]] -:hash: pass:normal[xref:#ERC4337Utils-hash-struct-PackedUserOperation-address-uint256-[`++hash++`]] +:hash: pass:normal[xref:#ERC4337Utils-hash-struct-PackedUserOperation-address-[`++hash++`]] :factory: pass:normal[xref:#ERC4337Utils-factory-struct-PackedUserOperation-[`++factory++`]] :factoryData: pass:normal[xref:#ERC4337Utils-factoryData-struct-PackedUserOperation-[`++factoryData++`]] :verificationGasLimit: pass:normal[xref:#ERC4337Utils-verificationGasLimit-struct-PackedUserOperation-[`++verificationGasLimit++`]] @@ -84,9 +88,27 @@ This directory includes contracts to build accounts for ERC-4337. :paymasterPostOpGasLimit: pass:normal[xref:#ERC4337Utils-paymasterPostOpGasLimit-struct-PackedUserOperation-[`++paymasterPostOpGasLimit++`]] :paymasterData: pass:normal[xref:#ERC4337Utils-paymasterData-struct-PackedUserOperation-[`++paymasterData++`]] +:parseValidationData-uint256: pass:normal[xref:#ERC4337Utils-parseValidationData-uint256-[`++parseValidationData++`]] +:packValidationData-address-uint48-uint48: pass:normal[xref:#ERC4337Utils-packValidationData-address-uint48-uint48-[`++packValidationData++`]] +:packValidationData-bool-uint48-uint48: pass:normal[xref:#ERC4337Utils-packValidationData-bool-uint48-uint48-[`++packValidationData++`]] +:combineValidationData-uint256-uint256: pass:normal[xref:#ERC4337Utils-combineValidationData-uint256-uint256-[`++combineValidationData++`]] +:getValidationData-uint256: pass:normal[xref:#ERC4337Utils-getValidationData-uint256-[`++getValidationData++`]] +:hash-struct-PackedUserOperation-address: pass:normal[xref:#ERC4337Utils-hash-struct-PackedUserOperation-address-[`++hash++`]] +:factory-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-factory-struct-PackedUserOperation-[`++factory++`]] +:factoryData-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-factoryData-struct-PackedUserOperation-[`++factoryData++`]] +:verificationGasLimit-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-verificationGasLimit-struct-PackedUserOperation-[`++verificationGasLimit++`]] +:callGasLimit-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-callGasLimit-struct-PackedUserOperation-[`++callGasLimit++`]] +:maxPriorityFeePerGas-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-maxPriorityFeePerGas-struct-PackedUserOperation-[`++maxPriorityFeePerGas++`]] +:maxFeePerGas-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-maxFeePerGas-struct-PackedUserOperation-[`++maxFeePerGas++`]] +:gasPrice-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-gasPrice-struct-PackedUserOperation-[`++gasPrice++`]] +:paymaster-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-paymaster-struct-PackedUserOperation-[`++paymaster++`]] +:paymasterVerificationGasLimit-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-paymasterVerificationGasLimit-struct-PackedUserOperation-[`++paymasterVerificationGasLimit++`]] +:paymasterPostOpGasLimit-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-paymasterPostOpGasLimit-struct-PackedUserOperation-[`++paymasterPostOpGasLimit++`]] +:paymasterData-struct-PackedUserOperation: pass:normal[xref:#ERC4337Utils-paymasterData-struct-PackedUserOperation-[`++paymasterData++`]] + [.contract] [[ERC4337Utils]] -=== `++ERC4337Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/account/utils/draft-ERC4337Utils.sol[{github-icon},role=heading-link] +=== `++ERC4337Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/account/utils/draft-ERC4337Utils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -105,7 +127,7 @@ See https://eips.ethereum.org/EIPS/eip-4337[ERC-4337]. * {xref-ERC4337Utils-packValidationData-bool-uint48-uint48-}[`++packValidationData(sigSuccess, validAfter, validUntil)++`] * {xref-ERC4337Utils-combineValidationData-uint256-uint256-}[`++combineValidationData(validationData1, validationData2)++`] * {xref-ERC4337Utils-getValidationData-uint256-}[`++getValidationData(validationData)++`] -* {xref-ERC4337Utils-hash-struct-PackedUserOperation-address-uint256-}[`++hash(self, entrypoint, chainid)++`] +* {xref-ERC4337Utils-hash-struct-PackedUserOperation-address-}[`++hash(self, entrypoint)++`] * {xref-ERC4337Utils-factory-struct-PackedUserOperation-}[`++factory(self)++`] * {xref-ERC4337Utils-factoryData-struct-PackedUserOperation-}[`++factoryData(self)++`] * {xref-ERC4337Utils-verificationGasLimit-struct-PackedUserOperation-}[`++verificationGasLimit(self)++`] @@ -123,6 +145,8 @@ See https://eips.ethereum.org/EIPS/eip-4337[ERC-4337]. [.contract-index] .Internal Variables -- +* {xref-ERC4337Utils-ENTRYPOINT_V07-contract-IEntryPoint}[`++contract IEntryPoint constant ENTRYPOINT_V07++`] +* {xref-ERC4337Utils-ENTRYPOINT_V08-contract-IEntryPoint}[`++contract IEntryPoint constant ENTRYPOINT_V08++`] * {xref-ERC4337Utils-SIG_VALIDATION_SUCCESS-uint256}[`++uint256 constant SIG_VALIDATION_SUCCESS++`] * {xref-ERC4337Utils-SIG_VALIDATION_FAILED-uint256}[`++uint256 constant SIG_VALIDATION_FAILED++`] @@ -162,10 +186,10 @@ the `validAfter` is the maximum and the `validUntil` is the minimum of both. Returns the aggregator of the `validationData` and whether it is out of time range. [.contract-item] -[[ERC4337Utils-hash-struct-PackedUserOperation-address-uint256-]] -==== `[.contract-item-name]#++hash++#++(struct PackedUserOperation self, address entrypoint, uint256 chainid) → bytes32++` [.item-kind]#internal# +[[ERC4337Utils-hash-struct-PackedUserOperation-address-]] +==== `[.contract-item-name]#++hash++#++(struct PackedUserOperation self, address entrypoint) → bytes32++` [.item-kind]#internal# -Computes the hash of a user operation for a given entrypoint and chainid. +Get the hash of a user operation for a given entrypoint [.contract-item] [[ERC4337Utils-factory-struct-PackedUserOperation-]] @@ -233,6 +257,18 @@ Returns the third section of `paymasterAndData` from the {PackedUserOperation}. Returns the fourth section of `paymasterAndData` from the {PackedUserOperation}. +[.contract-item] +[[ERC4337Utils-ENTRYPOINT_V07-contract-IEntryPoint]] +==== `contract IEntryPoint [.contract-item-name]#++ENTRYPOINT_V07++#` [.item-kind]#internal constant# + +Address of the entrypoint v0.7.0 + +[.contract-item] +[[ERC4337Utils-ENTRYPOINT_V08-contract-IEntryPoint]] +==== `contract IEntryPoint [.contract-item-name]#++ENTRYPOINT_V08++#` [.item-kind]#internal constant# + +Address of the entrypoint v0.8.0 + [.contract-item] [[ERC4337Utils-SIG_VALIDATION_SUCCESS-uint256]] ==== `uint256 [.contract-item-name]#++SIG_VALIDATION_SUCCESS++#` [.item-kind]#internal constant# @@ -270,9 +306,21 @@ For simulation purposes, validateUserOp (and validatePaymasterUserOp) must retur :encodeBatch: pass:normal[xref:#ERC7579Utils-encodeBatch-struct-Execution---[`++encodeBatch++`]] :decodeBatch: pass:normal[xref:#ERC7579Utils-decodeBatch-bytes-[`++decodeBatch++`]] +:execSingle-bytes-ExecType: pass:normal[xref:#ERC7579Utils-execSingle-bytes-ExecType-[`++execSingle++`]] +:execBatch-bytes-ExecType: pass:normal[xref:#ERC7579Utils-execBatch-bytes-ExecType-[`++execBatch++`]] +:execDelegateCall-bytes-ExecType: pass:normal[xref:#ERC7579Utils-execDelegateCall-bytes-ExecType-[`++execDelegateCall++`]] +:encodeMode-CallType-ExecType-ModeSelector-ModePayload: pass:normal[xref:#ERC7579Utils-encodeMode-CallType-ExecType-ModeSelector-ModePayload-[`++encodeMode++`]] +:decodeMode-Mode: pass:normal[xref:#ERC7579Utils-decodeMode-Mode-[`++decodeMode++`]] +:encodeSingle-address-uint256-bytes: pass:normal[xref:#ERC7579Utils-encodeSingle-address-uint256-bytes-[`++encodeSingle++`]] +:decodeSingle-bytes: pass:normal[xref:#ERC7579Utils-decodeSingle-bytes-[`++decodeSingle++`]] +:encodeDelegate-address-bytes: pass:normal[xref:#ERC7579Utils-encodeDelegate-address-bytes-[`++encodeDelegate++`]] +:decodeDelegate-bytes: pass:normal[xref:#ERC7579Utils-decodeDelegate-bytes-[`++decodeDelegate++`]] +:encodeBatch-struct-Execution--: pass:normal[xref:#ERC7579Utils-encodeBatch-struct-Execution---[`++encodeBatch++`]] +:decodeBatch-bytes: pass:normal[xref:#ERC7579Utils-decodeBatch-bytes-[`++decodeBatch++`]] + [.contract] [[ERC7579Utils]] -=== `++ERC7579Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/account/utils/draft-ERC7579Utils.sol[{github-icon},role=heading-link] +=== `++ERC7579Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/account/utils/draft-ERC7579Utils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity diff --git a/docs/modules/api/pages/finance.adoc b/docs/modules/api/pages/finance.adoc index 0e3861eb8..40d44d873 100644 --- a/docs/modules/api/pages/finance.adoc +++ b/docs/modules/api/pages/finance.adoc @@ -56,9 +56,24 @@ This directory includes primitives for financial systems: :vestedAmount: pass:normal[xref:#VestingWallet-vestedAmount-address-uint64-[`++vestedAmount++`]] :_vestingSchedule: pass:normal[xref:#VestingWallet-_vestingSchedule-uint256-uint64-[`++_vestingSchedule++`]] +:constructor-address-uint64-uint64: pass:normal[xref:#VestingWallet-constructor-address-uint64-uint64-[`++constructor++`]] +:receive-: pass:normal[xref:#VestingWallet-receive--[`++receive++`]] +:start-: pass:normal[xref:#VestingWallet-start--[`++start++`]] +:duration-: pass:normal[xref:#VestingWallet-duration--[`++duration++`]] +:end-: pass:normal[xref:#VestingWallet-end--[`++end++`]] +:released-: pass:normal[xref:#VestingWallet-released--[`++released++`]] +:released-address: pass:normal[xref:#VestingWallet-released-address-[`++released++`]] +:releasable-: pass:normal[xref:#VestingWallet-releasable--[`++releasable++`]] +:releasable-address: pass:normal[xref:#VestingWallet-releasable-address-[`++releasable++`]] +:release-: pass:normal[xref:#VestingWallet-release--[`++release++`]] +:release-address: pass:normal[xref:#VestingWallet-release-address-[`++release++`]] +:vestedAmount-uint64: pass:normal[xref:#VestingWallet-vestedAmount-uint64-[`++vestedAmount++`]] +:vestedAmount-address-uint64: pass:normal[xref:#VestingWallet-vestedAmount-address-uint64-[`++vestedAmount++`]] +:_vestingSchedule-uint256-uint64: pass:normal[xref:#VestingWallet-_vestingSchedule-uint256-uint64-[`++_vestingSchedule++`]] + [.contract] [[VestingWallet]] -=== `++VestingWallet++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/finance/VestingWallet.sol[{github-icon},role=heading-link] +=== `++VestingWallet++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/finance/VestingWallet.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -72,7 +87,7 @@ Any assets transferred to this contract will follow the vesting schedule as if t Consequently, if the vesting has already started, any amount of tokens sent to this contract will (at least partly) be immediately releasable. -By setting the duration to 0, one can configure this contract to behave like an asset timelock that hold tokens for +By setting the duration to 0, one can configure this contract to behave like an asset timelock that holds tokens for a beneficiary until a specified time. NOTE: Since the wallet is {Ownable}, and ownership can be transferred, it is possible to sell unvested tokens. diff --git a/docs/modules/api/pages/governance.adoc b/docs/modules/api/pages/governance.adoc index 9cddbf4de..a5f4a0fa9 100644 --- a/docs/modules/api/pages/governance.adoc +++ b/docs/modules/api/pages/governance.adoc @@ -1,12 +1,13 @@ :github-icon: pass:[] :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :GovernorVotes: pass:normal[xref:governance.adoc#GovernorVotes[`GovernorVotes`]] -:ERC20Votes: pass:normal[xref:token/ERC20.adoc#ERC20Votes[`ERC20Votes`]] -:ERC721Votes: pass:normal[xref:token/ERC721.adoc#ERC721Votes[`ERC721Votes`]] +:IVotes: pass:normal[xref:governance.adoc#IVotes[`IVotes`]] :GovernorVotesQuorumFraction: pass:normal[xref:governance.adoc#GovernorVotesQuorumFraction[`GovernorVotesQuorumFraction`]] +:GovernorVotesSuperQuorumFraction: pass:normal[xref:governance.adoc#GovernorVotesSuperQuorumFraction[`GovernorVotesSuperQuorumFraction`]] :GovernorCountingSimple: pass:normal[xref:governance.adoc#GovernorCountingSimple[`GovernorCountingSimple`]] :GovernorCountingFractional: pass:normal[xref:governance.adoc#GovernorCountingFractional[`GovernorCountingFractional`]] :GovernorCountingOverridable: pass:normal[xref:governance.adoc#GovernorCountingOverridable[`GovernorCountingOverridable`]] +:VotesExtended: pass:normal[xref:governance.adoc#VotesExtended[`VotesExtended`]] :GovernorTimelockAccess: pass:normal[xref:governance.adoc#GovernorTimelockAccess[`GovernorTimelockAccess`]] :AccessManager: pass:normal[xref:access.adoc#AccessManager[`AccessManager`]] :GovernorTimelockControl: pass:normal[xref:governance.adoc#GovernorTimelockControl[`GovernorTimelockControl`]] @@ -15,12 +16,16 @@ :GovernorStorage: pass:normal[xref:governance.adoc#GovernorStorage[`GovernorStorage`]] :GovernorSettings: pass:normal[xref:governance.adoc#GovernorSettings[`GovernorSettings`]] :GovernorPreventLateQuorum: pass:normal[xref:governance.adoc#GovernorPreventLateQuorum[`GovernorPreventLateQuorum`]] +:GovernorProposalGuardian: pass:normal[xref:governance.adoc#GovernorProposalGuardian[`GovernorProposalGuardian`]] +:GovernorSuperQuorum: pass:normal[xref:governance.adoc#GovernorSuperQuorum[`GovernorSuperQuorum`]] +:Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :Governor-_cancel: pass:normal[xref:governance.adoc#Governor-_cancel-address---uint256---bytes---bytes32-[`Governor._cancel`]] :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :xref-IGovernor-name--: xref:governance.adoc#IGovernor-name-- :xref-IGovernor-version--: xref:governance.adoc#IGovernor-version-- :xref-IGovernor-COUNTING_MODE--: xref:governance.adoc#IGovernor-COUNTING_MODE-- :xref-IGovernor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#IGovernor-hashProposal-address---uint256---bytes---bytes32- +:xref-IGovernor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#IGovernor-getProposalId-address---uint256---bytes---bytes32- :xref-IGovernor-state-uint256-: xref:governance.adoc#IGovernor-state-uint256- :xref-IGovernor-proposalThreshold--: xref:governance.adoc#IGovernor-proposalThreshold-- :xref-IGovernor-proposalSnapshot-uint256-: xref:governance.adoc#IGovernor-proposalSnapshot-uint256- @@ -55,7 +60,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -68,6 +72,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :IERC6372-clock: pass:normal[xref:interfaces.adoc#IERC6372-clock--[`IERC6372.clock`]] :ERC20Votes: pass:normal[xref:token/ERC20.adoc#ERC20Votes[`ERC20Votes`]] :ERC20Votes: pass:normal[xref:token/ERC20.adoc#ERC20Votes[`ERC20Votes`]] @@ -82,6 +87,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -121,6 +127,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -148,7 +155,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -161,12 +167,14 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :GovernorSettings: pass:normal[xref:governance.adoc#GovernorSettings[`GovernorSettings`]] :IERC165-supportsInterface: pass:normal[xref:utils.adoc#IERC165-supportsInterface-bytes4-[`IERC165.supportsInterface`]] :IGovernor-name: pass:normal[xref:governance.adoc#IGovernor-name--[`IGovernor.name`]] :IGovernor-version: pass:normal[xref:governance.adoc#IGovernor-version--[`IGovernor.version`]] :IGovernor-hashProposal: pass:normal[xref:governance.adoc#IGovernor-hashProposal-address---uint256---bytes---bytes32-[`IGovernor.hashProposal`]] +:IGovernor-getProposalId: pass:normal[xref:governance.adoc#IGovernor-getProposalId-address---uint256---bytes---bytes32-[`IGovernor.getProposalId`]] :IGovernor-state: pass:normal[xref:governance.adoc#IGovernor-state-uint256-[`IGovernor.state`]] :IGovernor-proposalThreshold: pass:normal[xref:governance.adoc#IGovernor-proposalThreshold--[`IGovernor.proposalThreshold`]] :IGovernor-proposalSnapshot: pass:normal[xref:governance.adoc#IGovernor-proposalSnapshot-uint256-[`IGovernor.proposalSnapshot`]] @@ -208,6 +216,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -244,6 +253,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -269,7 +279,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -282,6 +291,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :IGovernor-COUNTING_MODE: pass:normal[xref:governance.adoc#IGovernor-COUNTING_MODE--[`IGovernor.COUNTING_MODE`]] :IGovernor-hasVoted: pass:normal[xref:governance.adoc#IGovernor-hasVoted-uint256-address-[`IGovernor.hasVoted`]] @@ -303,6 +313,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -339,6 +350,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -365,7 +377,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -378,6 +389,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :xref-GovernorCountingFractional-VOTE_TYPE_FRACTIONAL-uint8: xref:governance.adoc#GovernorCountingFractional-VOTE_TYPE_FRACTIONAL-uint8 :IGovernor-COUNTING_MODE: pass:normal[xref:governance.adoc#IGovernor-COUNTING_MODE--[`IGovernor.COUNTING_MODE`]] @@ -387,6 +399,116 @@ :Governor-_countVote: pass:normal[xref:governance.adoc#Governor-_countVote-uint256-address-uint8-uint256-bytes-[`Governor._countVote`]] :GovernorCountingSimple: pass:normal[xref:governance.adoc#GovernorCountingSimple[`GovernorCountingSimple`]] :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] +:VotesExtended: pass:normal[xref:governance.adoc#VotesExtended[`VotesExtended`]] +:xref-GovernorCountingOverridable-COUNTING_MODE--: xref:governance.adoc#GovernorCountingOverridable-COUNTING_MODE-- +:xref-GovernorCountingOverridable-hasVoted-uint256-address-: xref:governance.adoc#GovernorCountingOverridable-hasVoted-uint256-address- +:xref-GovernorCountingOverridable-hasVotedOverride-uint256-address-: xref:governance.adoc#GovernorCountingOverridable-hasVotedOverride-uint256-address- +:xref-GovernorCountingOverridable-proposalVotes-uint256-: xref:governance.adoc#GovernorCountingOverridable-proposalVotes-uint256- +:xref-GovernorCountingOverridable-_quorumReached-uint256-: xref:governance.adoc#GovernorCountingOverridable-_quorumReached-uint256- +:xref-GovernorCountingOverridable-_voteSucceeded-uint256-: xref:governance.adoc#GovernorCountingOverridable-_voteSucceeded-uint256- +:xref-GovernorCountingOverridable-_countVote-uint256-address-uint8-uint256-bytes-: xref:governance.adoc#GovernorCountingOverridable-_countVote-uint256-address-uint8-uint256-bytes- +:xref-GovernorCountingOverridable-_countOverride-uint256-address-uint8-: xref:governance.adoc#GovernorCountingOverridable-_countOverride-uint256-address-uint8- +:xref-GovernorCountingOverridable-_castOverride-uint256-address-uint8-string-: xref:governance.adoc#GovernorCountingOverridable-_castOverride-uint256-address-uint8-string- +:xref-GovernorCountingOverridable-castOverrideVote-uint256-uint8-string-: xref:governance.adoc#GovernorCountingOverridable-castOverrideVote-uint256-uint8-string- +:xref-GovernorCountingOverridable-castOverrideVoteBySig-uint256-uint8-address-string-bytes-: xref:governance.adoc#GovernorCountingOverridable-castOverrideVoteBySig-uint256-uint8-address-string-bytes- +:xref-GovernorCountingOverridable-OVERRIDE_BALLOT_TYPEHASH-bytes32: xref:governance.adoc#GovernorCountingOverridable-OVERRIDE_BALLOT_TYPEHASH-bytes32 +:xref-GovernorVotes-token--: xref:governance.adoc#GovernorVotes-token-- +:xref-GovernorVotes-clock--: xref:governance.adoc#GovernorVotes-clock-- +:xref-GovernorVotes-CLOCK_MODE--: xref:governance.adoc#GovernorVotes-CLOCK_MODE-- +:xref-GovernorVotes-_getVotes-address-uint256-bytes-: xref:governance.adoc#GovernorVotes-_getVotes-address-uint256-bytes- +:xref-Governor-receive--: xref:governance.adoc#Governor-receive-- +:xref-Governor-supportsInterface-bytes4-: xref:governance.adoc#Governor-supportsInterface-bytes4- +:xref-Governor-name--: xref:governance.adoc#Governor-name-- +:xref-Governor-version--: xref:governance.adoc#Governor-version-- +:xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- +:xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- +:xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- +:xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- +:xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- +:xref-Governor-proposalProposer-uint256-: xref:governance.adoc#Governor-proposalProposer-uint256- +:xref-Governor-proposalEta-uint256-: xref:governance.adoc#Governor-proposalEta-uint256- +:xref-Governor-proposalNeedsQueuing-uint256-: xref:governance.adoc#Governor-proposalNeedsQueuing-uint256- +:xref-Governor-_checkGovernance--: xref:governance.adoc#Governor-_checkGovernance-- +:xref-Governor-_tallyUpdated-uint256-: xref:governance.adoc#Governor-_tallyUpdated-uint256- +:xref-Governor-_defaultParams--: xref:governance.adoc#Governor-_defaultParams-- +:xref-Governor-propose-address---uint256---bytes---string-: xref:governance.adoc#Governor-propose-address---uint256---bytes---string- +:xref-Governor-_propose-address---uint256---bytes---string-address-: xref:governance.adoc#Governor-_propose-address---uint256---bytes---string-address- +:xref-Governor-queue-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-queue-address---uint256---bytes---bytes32- +:xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_queueOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-execute-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-execute-address---uint256---bytes---bytes32- +:xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_executeOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-cancel-address---uint256---bytes---bytes32- +:xref-Governor-_cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_cancel-address---uint256---bytes---bytes32- +:xref-Governor-getVotes-address-uint256-: xref:governance.adoc#Governor-getVotes-address-uint256- +:xref-Governor-getVotesWithParams-address-uint256-bytes-: xref:governance.adoc#Governor-getVotesWithParams-address-uint256-bytes- +:xref-Governor-castVote-uint256-uint8-: xref:governance.adoc#Governor-castVote-uint256-uint8- +:xref-Governor-castVoteWithReason-uint256-uint8-string-: xref:governance.adoc#Governor-castVoteWithReason-uint256-uint8-string- +:xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes- +:xref-Governor-castVoteBySig-uint256-uint8-address-bytes-: xref:governance.adoc#Governor-castVoteBySig-uint256-uint8-address-bytes- +:xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes- +:xref-Governor-_castVote-uint256-address-uint8-string-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string- +:xref-Governor-_castVote-uint256-address-uint8-string-bytes-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string-bytes- +:xref-Governor-relay-address-uint256-bytes-: xref:governance.adoc#Governor-relay-address-uint256-bytes- +:xref-Governor-_executor--: xref:governance.adoc#Governor-_executor-- +:xref-Governor-onERC721Received-address-address-uint256-bytes-: xref:governance.adoc#Governor-onERC721Received-address-address-uint256-bytes- +:xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-: xref:governance.adoc#Governor-onERC1155Received-address-address-uint256-uint256-bytes- +:xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-: xref:governance.adoc#Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes- +:xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- +:xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- +:xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- +:xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- +:xref-Governor-votingPeriod--: xref:governance.adoc#Governor-votingPeriod-- +:xref-Governor-quorum-uint256-: xref:governance.adoc#Governor-quorum-uint256- +:xref-Governor-BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-BALLOT_TYPEHASH-bytes32 +:xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-EXTENDED_BALLOT_TYPEHASH-bytes32 +:xref-Nonces-nonces-address-: xref:utils.adoc#Nonces-nonces-address- +:xref-Nonces-_useNonce-address-: xref:utils.adoc#Nonces-_useNonce-address- +:xref-Nonces-_useCheckedNonce-address-uint256-: xref:utils.adoc#Nonces-_useCheckedNonce-address-uint256- +:xref-EIP712-_domainSeparatorV4--: xref:utils.adoc#EIP712-_domainSeparatorV4-- +:xref-EIP712-_hashTypedDataV4-bytes32-: xref:utils.adoc#EIP712-_hashTypedDataV4-bytes32- +:xref-EIP712-eip712Domain--: xref:utils.adoc#EIP712-eip712Domain-- +:xref-EIP712-_EIP712Name--: xref:utils.adoc#EIP712-_EIP712Name-- +:xref-EIP712-_EIP712Version--: xref:utils.adoc#EIP712-_EIP712Version-- +:xref-GovernorCountingOverridable-VoteReduced-address-uint256-uint8-uint256-: xref:governance.adoc#GovernorCountingOverridable-VoteReduced-address-uint256-uint8-uint256- +:xref-GovernorCountingOverridable-OverrideVoteCast-address-uint256-uint8-uint256-string-: xref:governance.adoc#GovernorCountingOverridable-OverrideVoteCast-address-uint256-uint8-uint256-string- +:xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-: xref:governance.adoc#IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string- +:xref-IGovernor-ProposalQueued-uint256-uint256-: xref:governance.adoc#IGovernor-ProposalQueued-uint256-uint256- +:xref-IGovernor-ProposalExecuted-uint256-: xref:governance.adoc#IGovernor-ProposalExecuted-uint256- +:xref-IGovernor-ProposalCanceled-uint256-: xref:governance.adoc#IGovernor-ProposalCanceled-uint256- +:xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-: xref:governance.adoc#IGovernor-VoteCast-address-uint256-uint8-uint256-string- +:xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-: xref:governance.adoc#IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes- +:xref-IERC5267-EIP712DomainChanged--: xref:interfaces.adoc#IERC5267-EIP712DomainChanged-- +:xref-GovernorCountingOverridable-GovernorAlreadyOverriddenVote-address-: xref:governance.adoc#GovernorCountingOverridable-GovernorAlreadyOverriddenVote-address- +:xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- +:xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- +:xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- +:xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- +:xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- +:xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- +:xref-IGovernor-GovernorInvalidVotingPeriod-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidVotingPeriod-uint256- +:xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256- +:xref-IGovernor-GovernorRestrictedProposer-address-: xref:governance.adoc#IGovernor-GovernorRestrictedProposer-address- +:xref-IGovernor-GovernorInvalidVoteType--: xref:governance.adoc#IGovernor-GovernorInvalidVoteType-- +:xref-IGovernor-GovernorInvalidVoteParams--: xref:governance.adoc#IGovernor-GovernorInvalidVoteParams-- +:xref-IGovernor-GovernorQueueNotImplemented--: xref:governance.adoc#IGovernor-GovernorQueueNotImplemented-- +:xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- +:xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- +:xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- +:xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- +:IGovernor-COUNTING_MODE: pass:normal[xref:governance.adoc#IGovernor-COUNTING_MODE--[`IGovernor.COUNTING_MODE`]] +:IGovernor-hasVoted: pass:normal[xref:governance.adoc#IGovernor-hasVoted-uint256-address-[`IGovernor.hasVoted`]] +:Governor-_quorumReached: pass:normal[xref:governance.adoc#Governor-_quorumReached-uint256-[`Governor._quorumReached`]] +:Governor-_voteSucceeded: pass:normal[xref:governance.adoc#Governor-_voteSucceeded-uint256-[`Governor._voteSucceeded`]] +:Governor-_countVote: pass:normal[xref:governance.adoc#Governor-_countVote-uint256-address-uint8-uint256-bytes-[`Governor._countVote`]] +:Governor-_castVote: pass:normal[xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string-bytes-[`Governor._castVote`]] +:IGovernor-VoteCast: pass:normal[xref:governance.adoc#IGovernor-VoteCast-address-uint256-uint8-uint256-string-[`IGovernor.VoteCast`]] +:IGovernor-VoteCastWithParams: pass:normal[xref:governance.adoc#IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-[`IGovernor.VoteCastWithParams`]] +:Governor-_countVote: pass:normal[xref:governance.adoc#Governor-_countVote-uint256-address-uint8-uint256-bytes-[`Governor._countVote`]] +:Governor-_castVote: pass:normal[xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string-bytes-[`Governor._castVote`]] +:Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :ERC20Votes: pass:normal[xref:token/ERC20.adoc#ERC20Votes[`ERC20Votes`]] :ERC721Votes: pass:normal[xref:token/ERC721.adoc#ERC721Votes[`ERC721Votes`]] :xref-GovernorVotes-constructor-contract-IVotes-: xref:governance.adoc#GovernorVotes-constructor-contract-IVotes- @@ -399,6 +521,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -437,6 +560,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- :xref-Governor-votingPeriod--: xref:governance.adoc#Governor-votingPeriod-- :xref-Governor-quorum-uint256-: xref:governance.adoc#Governor-quorum-uint256- @@ -462,7 +586,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -475,6 +598,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :ERC20Votes: pass:normal[xref:token/ERC20.adoc#ERC20Votes[`ERC20Votes`]] @@ -485,6 +609,7 @@ :xref-GovernorVotesQuorumFraction-quorum-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-quorum-uint256- :xref-GovernorVotesQuorumFraction-updateQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-updateQuorumNumerator-uint256- :xref-GovernorVotesQuorumFraction-_updateQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-_updateQuorumNumerator-uint256- +:xref-GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256- :xref-GovernorVotes-token--: xref:governance.adoc#GovernorVotes-token-- :xref-GovernorVotes-clock--: xref:governance.adoc#GovernorVotes-clock-- :xref-GovernorVotes-CLOCK_MODE--: xref:governance.adoc#GovernorVotes-CLOCK_MODE-- @@ -494,6 +619,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -532,6 +658,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- :xref-Governor-votingPeriod--: xref:governance.adoc#Governor-votingPeriod-- :xref-Governor-BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-BALLOT_TYPEHASH-bytes32 @@ -558,7 +685,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -571,7 +697,119 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- +:GovernorVotesQuorumFraction: pass:normal[xref:governance.adoc#GovernorVotesQuorumFraction[`GovernorVotesQuorumFraction`]] +:xref-GovernorVotesSuperQuorumFraction-constructor-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-constructor-uint256- +:xref-GovernorVotesSuperQuorumFraction-superQuorumNumerator--: xref:governance.adoc#GovernorVotesSuperQuorumFraction-superQuorumNumerator-- +:xref-GovernorVotesSuperQuorumFraction-superQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-superQuorumNumerator-uint256- +:xref-GovernorVotesSuperQuorumFraction-superQuorum-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-superQuorum-uint256- +:xref-GovernorVotesSuperQuorumFraction-updateSuperQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-updateSuperQuorumNumerator-uint256- +:xref-GovernorVotesSuperQuorumFraction-_updateSuperQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-_updateSuperQuorumNumerator-uint256- +:xref-GovernorVotesSuperQuorumFraction-_updateQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-_updateQuorumNumerator-uint256- +:xref-GovernorVotesSuperQuorumFraction-state-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-state-uint256- +:xref-GovernorSuperQuorum-proposalVotes-uint256-: xref:governance.adoc#GovernorSuperQuorum-proposalVotes-uint256- +:xref-GovernorVotesQuorumFraction-quorumNumerator--: xref:governance.adoc#GovernorVotesQuorumFraction-quorumNumerator-- +:xref-GovernorVotesQuorumFraction-quorumNumerator-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-quorumNumerator-uint256- +:xref-GovernorVotesQuorumFraction-quorumDenominator--: xref:governance.adoc#GovernorVotesQuorumFraction-quorumDenominator-- +:xref-GovernorVotesQuorumFraction-quorum-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-quorum-uint256- +:xref-GovernorVotesQuorumFraction-updateQuorumNumerator-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-updateQuorumNumerator-uint256- +:xref-GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256- +:xref-GovernorVotes-token--: xref:governance.adoc#GovernorVotes-token-- +:xref-GovernorVotes-clock--: xref:governance.adoc#GovernorVotes-clock-- +:xref-GovernorVotes-CLOCK_MODE--: xref:governance.adoc#GovernorVotes-CLOCK_MODE-- +:xref-GovernorVotes-_getVotes-address-uint256-bytes-: xref:governance.adoc#GovernorVotes-_getVotes-address-uint256-bytes- +:xref-Governor-receive--: xref:governance.adoc#Governor-receive-- +:xref-Governor-supportsInterface-bytes4-: xref:governance.adoc#Governor-supportsInterface-bytes4- +:xref-Governor-name--: xref:governance.adoc#Governor-name-- +:xref-Governor-version--: xref:governance.adoc#Governor-version-- +:xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- +:xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- +:xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- +:xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- +:xref-Governor-proposalProposer-uint256-: xref:governance.adoc#Governor-proposalProposer-uint256- +:xref-Governor-proposalEta-uint256-: xref:governance.adoc#Governor-proposalEta-uint256- +:xref-Governor-proposalNeedsQueuing-uint256-: xref:governance.adoc#Governor-proposalNeedsQueuing-uint256- +:xref-Governor-_checkGovernance--: xref:governance.adoc#Governor-_checkGovernance-- +:xref-Governor-_quorumReached-uint256-: xref:governance.adoc#Governor-_quorumReached-uint256- +:xref-Governor-_voteSucceeded-uint256-: xref:governance.adoc#Governor-_voteSucceeded-uint256- +:xref-Governor-_countVote-uint256-address-uint8-uint256-bytes-: xref:governance.adoc#Governor-_countVote-uint256-address-uint8-uint256-bytes- +:xref-Governor-_tallyUpdated-uint256-: xref:governance.adoc#Governor-_tallyUpdated-uint256- +:xref-Governor-_defaultParams--: xref:governance.adoc#Governor-_defaultParams-- +:xref-Governor-propose-address---uint256---bytes---string-: xref:governance.adoc#Governor-propose-address---uint256---bytes---string- +:xref-Governor-_propose-address---uint256---bytes---string-address-: xref:governance.adoc#Governor-_propose-address---uint256---bytes---string-address- +:xref-Governor-queue-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-queue-address---uint256---bytes---bytes32- +:xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_queueOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-execute-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-execute-address---uint256---bytes---bytes32- +:xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_executeOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-cancel-address---uint256---bytes---bytes32- +:xref-Governor-_cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_cancel-address---uint256---bytes---bytes32- +:xref-Governor-getVotes-address-uint256-: xref:governance.adoc#Governor-getVotes-address-uint256- +:xref-Governor-getVotesWithParams-address-uint256-bytes-: xref:governance.adoc#Governor-getVotesWithParams-address-uint256-bytes- +:xref-Governor-castVote-uint256-uint8-: xref:governance.adoc#Governor-castVote-uint256-uint8- +:xref-Governor-castVoteWithReason-uint256-uint8-string-: xref:governance.adoc#Governor-castVoteWithReason-uint256-uint8-string- +:xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes- +:xref-Governor-castVoteBySig-uint256-uint8-address-bytes-: xref:governance.adoc#Governor-castVoteBySig-uint256-uint8-address-bytes- +:xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes- +:xref-Governor-_castVote-uint256-address-uint8-string-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string- +:xref-Governor-_castVote-uint256-address-uint8-string-bytes-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string-bytes- +:xref-Governor-relay-address-uint256-bytes-: xref:governance.adoc#Governor-relay-address-uint256-bytes- +:xref-Governor-_executor--: xref:governance.adoc#Governor-_executor-- +:xref-Governor-onERC721Received-address-address-uint256-bytes-: xref:governance.adoc#Governor-onERC721Received-address-address-uint256-bytes- +:xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-: xref:governance.adoc#Governor-onERC1155Received-address-address-uint256-uint256-bytes- +:xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-: xref:governance.adoc#Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes- +:xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- +:xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- +:xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- +:xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- +:xref-Governor-votingPeriod--: xref:governance.adoc#Governor-votingPeriod-- +:xref-Governor-BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-BALLOT_TYPEHASH-bytes32 +:xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-EXTENDED_BALLOT_TYPEHASH-bytes32 +:xref-IGovernor-COUNTING_MODE--: xref:governance.adoc#IGovernor-COUNTING_MODE-- +:xref-IGovernor-hasVoted-uint256-address-: xref:governance.adoc#IGovernor-hasVoted-uint256-address- +:xref-Nonces-nonces-address-: xref:utils.adoc#Nonces-nonces-address- +:xref-Nonces-_useNonce-address-: xref:utils.adoc#Nonces-_useNonce-address- +:xref-Nonces-_useCheckedNonce-address-uint256-: xref:utils.adoc#Nonces-_useCheckedNonce-address-uint256- +:xref-EIP712-_domainSeparatorV4--: xref:utils.adoc#EIP712-_domainSeparatorV4-- +:xref-EIP712-_hashTypedDataV4-bytes32-: xref:utils.adoc#EIP712-_hashTypedDataV4-bytes32- +:xref-EIP712-eip712Domain--: xref:utils.adoc#EIP712-eip712Domain-- +:xref-EIP712-_EIP712Name--: xref:utils.adoc#EIP712-_EIP712Name-- +:xref-EIP712-_EIP712Version--: xref:utils.adoc#EIP712-_EIP712Version-- +:xref-GovernorVotesSuperQuorumFraction-SuperQuorumNumeratorUpdated-uint256-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-SuperQuorumNumeratorUpdated-uint256-uint256- +:xref-GovernorVotesQuorumFraction-QuorumNumeratorUpdated-uint256-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-QuorumNumeratorUpdated-uint256-uint256- +:xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-: xref:governance.adoc#IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string- +:xref-IGovernor-ProposalQueued-uint256-uint256-: xref:governance.adoc#IGovernor-ProposalQueued-uint256-uint256- +:xref-IGovernor-ProposalExecuted-uint256-: xref:governance.adoc#IGovernor-ProposalExecuted-uint256- +:xref-IGovernor-ProposalCanceled-uint256-: xref:governance.adoc#IGovernor-ProposalCanceled-uint256- +:xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-: xref:governance.adoc#IGovernor-VoteCast-address-uint256-uint8-uint256-string- +:xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-: xref:governance.adoc#IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes- +:xref-IERC5267-EIP712DomainChanged--: xref:interfaces.adoc#IERC5267-EIP712DomainChanged-- +:xref-GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumFraction-uint256-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumFraction-uint256-uint256- +:xref-GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumTooSmall-uint256-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumTooSmall-uint256-uint256- +:xref-GovernorVotesSuperQuorumFraction-GovernorInvalidQuorumTooLarge-uint256-uint256-: xref:governance.adoc#GovernorVotesSuperQuorumFraction-GovernorInvalidQuorumTooLarge-uint256-uint256- +:xref-GovernorVotesQuorumFraction-GovernorInvalidQuorumFraction-uint256-uint256-: xref:governance.adoc#GovernorVotesQuorumFraction-GovernorInvalidQuorumFraction-uint256-uint256- +:xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- +:xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- +:xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- +:xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- +:xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- +:xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- +:xref-IGovernor-GovernorInvalidVotingPeriod-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidVotingPeriod-uint256- +:xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256- +:xref-IGovernor-GovernorRestrictedProposer-address-: xref:governance.adoc#IGovernor-GovernorRestrictedProposer-address- +:xref-IGovernor-GovernorInvalidVoteType--: xref:governance.adoc#IGovernor-GovernorInvalidVoteType-- +:xref-IGovernor-GovernorInvalidVoteParams--: xref:governance.adoc#IGovernor-GovernorInvalidVoteParams-- +:xref-IGovernor-GovernorQueueNotImplemented--: xref:governance.adoc#IGovernor-GovernorQueueNotImplemented-- +:xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- +:xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- +:xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- +:xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- +:GovernorSuperQuorum-superQuorum: pass:normal[xref:governance.adoc#GovernorSuperQuorum-superQuorum-uint256-[`GovernorSuperQuorum.superQuorum`]] +:GovernorVotesQuorumFraction-_updateQuorumNumerator: pass:normal[xref:governance.adoc#GovernorVotesQuorumFraction-_updateQuorumNumerator-uint256-[`GovernorVotesQuorumFraction._updateQuorumNumerator`]] +:Governor-state: pass:normal[xref:governance.adoc#Governor-state-uint256-[`Governor.state`]] :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :AccessManager: pass:normal[xref:access.adoc#AccessManager[`AccessManager`]] :GovernorTimelockControl: pass:normal[xref:governance.adoc#GovernorTimelockControl[`GovernorTimelockControl`]] @@ -597,6 +835,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -631,6 +870,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -663,7 +903,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -676,6 +915,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :AccessManager: pass:normal[xref:access.adoc#AccessManager[`AccessManager`]] :AccessManager: pass:normal[xref:access.adoc#AccessManager[`AccessManager`]] @@ -685,6 +925,7 @@ :IGovernor-proposalNeedsQueuing: pass:normal[xref:governance.adoc#IGovernor-proposalNeedsQueuing-uint256-[`IGovernor.proposalNeedsQueuing`]] :IGovernor-propose: pass:normal[xref:governance.adoc#IGovernor-propose-address---uint256---bytes---string-[`IGovernor.propose`]] :AccessManager-execute: pass:normal[xref:access.adoc#AccessManager-execute-address-bytes-[`AccessManager.execute`]] +:Governor-_cancel: pass:normal[xref:governance.adoc#Governor-_cancel-address---uint256---bytes---bytes32-[`Governor._cancel`]] :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] :TimelockController: pass:normal[xref:governance.adoc#TimelockController[`TimelockController`]] :TimelockController: pass:normal[xref:governance.adoc#TimelockController[`TimelockController`]] @@ -709,6 +950,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- :xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- @@ -742,6 +984,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -770,7 +1013,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -783,6 +1025,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :Governor-state: pass:normal[xref:governance.adoc#Governor-state-uint256-[`Governor.state`]] :IGovernor-proposalNeedsQueuing: pass:normal[xref:governance.adoc#IGovernor-proposalNeedsQueuing-uint256-[`IGovernor.proposalNeedsQueuing`]] @@ -811,6 +1054,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- :xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- @@ -844,6 +1088,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -872,7 +1117,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -885,6 +1129,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :Governor-state: pass:normal[xref:governance.adoc#Governor-state-uint256-[`Governor.state`]] :IGovernor-proposalNeedsQueuing: pass:normal[xref:governance.adoc#IGovernor-proposalNeedsQueuing-uint256-[`IGovernor.proposalNeedsQueuing`]] @@ -906,6 +1151,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- :xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- @@ -944,6 +1190,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-quorum-uint256-: xref:governance.adoc#Governor-quorum-uint256- @@ -972,7 +1219,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -985,6 +1231,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :IGovernor-votingDelay: pass:normal[xref:governance.adoc#IGovernor-votingDelay--[`IGovernor.votingDelay`]] :IGovernor-votingPeriod: pass:normal[xref:governance.adoc#IGovernor-votingPeriod--[`IGovernor.votingPeriod`]] @@ -1000,6 +1247,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -1037,6 +1285,7 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -1066,7 +1315,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -1079,6 +1327,7 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- :Governor-proposalDeadline: pass:normal[xref:governance.adoc#Governor-proposalDeadline-uint256-[`Governor.proposalDeadline`]] :Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] @@ -1096,6 +1345,7 @@ :xref-Governor-name--: xref:governance.adoc#Governor-name-- :xref-Governor-version--: xref:governance.adoc#Governor-version-- :xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- :xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- :xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- :xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- @@ -1134,6 +1384,101 @@ :xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- :xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- :xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- +:xref-Governor-clock--: xref:governance.adoc#Governor-clock-- +:xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- +:xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- +:xref-Governor-votingPeriod--: xref:governance.adoc#Governor-votingPeriod-- +:xref-Governor-quorum-uint256-: xref:governance.adoc#Governor-quorum-uint256- +:xref-Governor-BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-BALLOT_TYPEHASH-bytes32 +:xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-EXTENDED_BALLOT_TYPEHASH-bytes32 +:xref-IGovernor-COUNTING_MODE--: xref:governance.adoc#IGovernor-COUNTING_MODE-- +:xref-IGovernor-hasVoted-uint256-address-: xref:governance.adoc#IGovernor-hasVoted-uint256-address- +:xref-Nonces-nonces-address-: xref:utils.adoc#Nonces-nonces-address- +:xref-Nonces-_useNonce-address-: xref:utils.adoc#Nonces-_useNonce-address- +:xref-Nonces-_useCheckedNonce-address-uint256-: xref:utils.adoc#Nonces-_useCheckedNonce-address-uint256- +:xref-EIP712-_domainSeparatorV4--: xref:utils.adoc#EIP712-_domainSeparatorV4-- +:xref-EIP712-_hashTypedDataV4-bytes32-: xref:utils.adoc#EIP712-_hashTypedDataV4-bytes32- +:xref-EIP712-eip712Domain--: xref:utils.adoc#EIP712-eip712Domain-- +:xref-EIP712-_EIP712Name--: xref:utils.adoc#EIP712-_EIP712Name-- +:xref-EIP712-_EIP712Version--: xref:utils.adoc#EIP712-_EIP712Version-- +:xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-: xref:governance.adoc#IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string- +:xref-IGovernor-ProposalQueued-uint256-uint256-: xref:governance.adoc#IGovernor-ProposalQueued-uint256-uint256- +:xref-IGovernor-ProposalExecuted-uint256-: xref:governance.adoc#IGovernor-ProposalExecuted-uint256- +:xref-IGovernor-ProposalCanceled-uint256-: xref:governance.adoc#IGovernor-ProposalCanceled-uint256- +:xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-: xref:governance.adoc#IGovernor-VoteCast-address-uint256-uint8-uint256-string- +:xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-: xref:governance.adoc#IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes- +:xref-IERC5267-EIP712DomainChanged--: xref:interfaces.adoc#IERC5267-EIP712DomainChanged-- +:xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- +:xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- +:xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- +:xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- +:xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- +:xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- +:xref-IGovernor-GovernorInvalidVotingPeriod-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidVotingPeriod-uint256- +:xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256- +:xref-IGovernor-GovernorRestrictedProposer-address-: xref:governance.adoc#IGovernor-GovernorRestrictedProposer-address- +:xref-IGovernor-GovernorInvalidVoteType--: xref:governance.adoc#IGovernor-GovernorInvalidVoteType-- +:xref-IGovernor-GovernorInvalidVoteParams--: xref:governance.adoc#IGovernor-GovernorInvalidVoteParams-- +:xref-IGovernor-GovernorQueueNotImplemented--: xref:governance.adoc#IGovernor-GovernorQueueNotImplemented-- +:xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- +:xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- +:xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- +:xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- +:IGovernor-queue: pass:normal[xref:governance.adoc#IGovernor-queue-address---uint256---bytes---bytes32-[`IGovernor.queue`]] +:IGovernor-execute: pass:normal[xref:governance.adoc#IGovernor-execute-address---uint256---bytes---bytes32-[`IGovernor.execute`]] +:IGovernor-cancel: pass:normal[xref:governance.adoc#IGovernor-cancel-address---uint256---bytes---bytes32-[`IGovernor.cancel`]] +:Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] +:xref-GovernorProposalGuardian-proposalGuardian--: xref:governance.adoc#GovernorProposalGuardian-proposalGuardian-- +:xref-GovernorProposalGuardian-setProposalGuardian-address-: xref:governance.adoc#GovernorProposalGuardian-setProposalGuardian-address- +:xref-GovernorProposalGuardian-_setProposalGuardian-address-: xref:governance.adoc#GovernorProposalGuardian-_setProposalGuardian-address- +:xref-GovernorProposalGuardian-_validateCancel-uint256-address-: xref:governance.adoc#GovernorProposalGuardian-_validateCancel-uint256-address- +:xref-Governor-receive--: xref:governance.adoc#Governor-receive-- +:xref-Governor-supportsInterface-bytes4-: xref:governance.adoc#Governor-supportsInterface-bytes4- +:xref-Governor-name--: xref:governance.adoc#Governor-name-- +:xref-Governor-version--: xref:governance.adoc#Governor-version-- +:xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- +:xref-Governor-state-uint256-: xref:governance.adoc#Governor-state-uint256- +:xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- +:xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- +:xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- +:xref-Governor-proposalProposer-uint256-: xref:governance.adoc#Governor-proposalProposer-uint256- +:xref-Governor-proposalEta-uint256-: xref:governance.adoc#Governor-proposalEta-uint256- +:xref-Governor-proposalNeedsQueuing-uint256-: xref:governance.adoc#Governor-proposalNeedsQueuing-uint256- +:xref-Governor-_checkGovernance--: xref:governance.adoc#Governor-_checkGovernance-- +:xref-Governor-_quorumReached-uint256-: xref:governance.adoc#Governor-_quorumReached-uint256- +:xref-Governor-_voteSucceeded-uint256-: xref:governance.adoc#Governor-_voteSucceeded-uint256- +:xref-Governor-_getVotes-address-uint256-bytes-: xref:governance.adoc#Governor-_getVotes-address-uint256-bytes- +:xref-Governor-_countVote-uint256-address-uint8-uint256-bytes-: xref:governance.adoc#Governor-_countVote-uint256-address-uint8-uint256-bytes- +:xref-Governor-_tallyUpdated-uint256-: xref:governance.adoc#Governor-_tallyUpdated-uint256- +:xref-Governor-_defaultParams--: xref:governance.adoc#Governor-_defaultParams-- +:xref-Governor-propose-address---uint256---bytes---string-: xref:governance.adoc#Governor-propose-address---uint256---bytes---string- +:xref-Governor-_propose-address---uint256---bytes---string-address-: xref:governance.adoc#Governor-_propose-address---uint256---bytes---string-address- +:xref-Governor-queue-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-queue-address---uint256---bytes---bytes32- +:xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_queueOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-execute-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-execute-address---uint256---bytes---bytes32- +:xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_executeOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-cancel-address---uint256---bytes---bytes32- +:xref-Governor-_cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_cancel-address---uint256---bytes---bytes32- +:xref-Governor-getVotes-address-uint256-: xref:governance.adoc#Governor-getVotes-address-uint256- +:xref-Governor-getVotesWithParams-address-uint256-bytes-: xref:governance.adoc#Governor-getVotesWithParams-address-uint256-bytes- +:xref-Governor-castVote-uint256-uint8-: xref:governance.adoc#Governor-castVote-uint256-uint8- +:xref-Governor-castVoteWithReason-uint256-uint8-string-: xref:governance.adoc#Governor-castVoteWithReason-uint256-uint8-string- +:xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes- +:xref-Governor-castVoteBySig-uint256-uint8-address-bytes-: xref:governance.adoc#Governor-castVoteBySig-uint256-uint8-address-bytes- +:xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes- +:xref-Governor-_castVote-uint256-address-uint8-string-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string- +:xref-Governor-_castVote-uint256-address-uint8-string-bytes-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string-bytes- +:xref-Governor-relay-address-uint256-bytes-: xref:governance.adoc#Governor-relay-address-uint256-bytes- +:xref-Governor-_executor--: xref:governance.adoc#Governor-_executor-- +:xref-Governor-onERC721Received-address-address-uint256-bytes-: xref:governance.adoc#Governor-onERC721Received-address-address-uint256-bytes- +:xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-: xref:governance.adoc#Governor-onERC1155Received-address-address-uint256-uint256-bytes- +:xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-: xref:governance.adoc#Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes- +:xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- +:xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- +:xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- :xref-Governor-clock--: xref:governance.adoc#Governor-clock-- :xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- :xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- @@ -1151,6 +1496,7 @@ :xref-EIP712-eip712Domain--: xref:utils.adoc#EIP712-eip712Domain-- :xref-EIP712-_EIP712Name--: xref:utils.adoc#EIP712-_EIP712Name-- :xref-EIP712-_EIP712Version--: xref:utils.adoc#EIP712-_EIP712Version-- +:xref-GovernorProposalGuardian-ProposalGuardianSet-address-address-: xref:governance.adoc#GovernorProposalGuardian-ProposalGuardianSet-address-address- :xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-: xref:governance.adoc#IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string- :xref-IGovernor-ProposalQueued-uint256-uint256-: xref:governance.adoc#IGovernor-ProposalQueued-uint256-uint256- :xref-IGovernor-ProposalExecuted-uint256-: xref:governance.adoc#IGovernor-ProposalExecuted-uint256- @@ -1161,7 +1507,6 @@ :xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- :xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- :xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- -:xref-IGovernor-GovernorOnlyProposer-address-: xref:governance.adoc#IGovernor-GovernorOnlyProposer-address- :xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- :xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- :xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- @@ -1174,9 +1519,103 @@ :xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- :xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- :xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- :xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- -:IGovernor-execute: pass:normal[xref:governance.adoc#IGovernor-execute-address---uint256---bytes---bytes32-[`IGovernor.execute`]] -:IGovernor-cancel: pass:normal[xref:governance.adoc#IGovernor-cancel-address---uint256---bytes---bytes32-[`IGovernor.cancel`]] +:Governor-_validateCancel: pass:normal[xref:governance.adoc#Governor-_validateCancel-uint256-address-[`Governor._validateCancel`]] +:IGovernor-proposalProposer: pass:normal[xref:governance.adoc#IGovernor-proposalProposer-uint256-[`IGovernor.proposalProposer`]] +:Governor-_validateCancel: pass:normal[xref:governance.adoc#Governor-_validateCancel-uint256-address-[`Governor._validateCancel`]] +:Governor: pass:normal[xref:governance.adoc#Governor[`Governor`]] +:xref-GovernorSuperQuorum-superQuorum-uint256-: xref:governance.adoc#GovernorSuperQuorum-superQuorum-uint256- +:xref-GovernorSuperQuorum-proposalVotes-uint256-: xref:governance.adoc#GovernorSuperQuorum-proposalVotes-uint256- +:xref-GovernorSuperQuorum-state-uint256-: xref:governance.adoc#GovernorSuperQuorum-state-uint256- +:xref-Governor-receive--: xref:governance.adoc#Governor-receive-- +:xref-Governor-supportsInterface-bytes4-: xref:governance.adoc#Governor-supportsInterface-bytes4- +:xref-Governor-name--: xref:governance.adoc#Governor-name-- +:xref-Governor-version--: xref:governance.adoc#Governor-version-- +:xref-Governor-hashProposal-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-hashProposal-address---uint256---bytes---bytes32- +:xref-Governor-getProposalId-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-getProposalId-address---uint256---bytes---bytes32- +:xref-Governor-proposalThreshold--: xref:governance.adoc#Governor-proposalThreshold-- +:xref-Governor-proposalSnapshot-uint256-: xref:governance.adoc#Governor-proposalSnapshot-uint256- +:xref-Governor-proposalDeadline-uint256-: xref:governance.adoc#Governor-proposalDeadline-uint256- +:xref-Governor-proposalProposer-uint256-: xref:governance.adoc#Governor-proposalProposer-uint256- +:xref-Governor-proposalEta-uint256-: xref:governance.adoc#Governor-proposalEta-uint256- +:xref-Governor-proposalNeedsQueuing-uint256-: xref:governance.adoc#Governor-proposalNeedsQueuing-uint256- +:xref-Governor-_checkGovernance--: xref:governance.adoc#Governor-_checkGovernance-- +:xref-Governor-_quorumReached-uint256-: xref:governance.adoc#Governor-_quorumReached-uint256- +:xref-Governor-_voteSucceeded-uint256-: xref:governance.adoc#Governor-_voteSucceeded-uint256- +:xref-Governor-_getVotes-address-uint256-bytes-: xref:governance.adoc#Governor-_getVotes-address-uint256-bytes- +:xref-Governor-_countVote-uint256-address-uint8-uint256-bytes-: xref:governance.adoc#Governor-_countVote-uint256-address-uint8-uint256-bytes- +:xref-Governor-_tallyUpdated-uint256-: xref:governance.adoc#Governor-_tallyUpdated-uint256- +:xref-Governor-_defaultParams--: xref:governance.adoc#Governor-_defaultParams-- +:xref-Governor-propose-address---uint256---bytes---string-: xref:governance.adoc#Governor-propose-address---uint256---bytes---string- +:xref-Governor-_propose-address---uint256---bytes---string-address-: xref:governance.adoc#Governor-_propose-address---uint256---bytes---string-address- +:xref-Governor-queue-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-queue-address---uint256---bytes---bytes32- +:xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_queueOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-execute-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-execute-address---uint256---bytes---bytes32- +:xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_executeOperations-uint256-address---uint256---bytes---bytes32- +:xref-Governor-cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-cancel-address---uint256---bytes---bytes32- +:xref-Governor-_cancel-address---uint256---bytes---bytes32-: xref:governance.adoc#Governor-_cancel-address---uint256---bytes---bytes32- +:xref-Governor-getVotes-address-uint256-: xref:governance.adoc#Governor-getVotes-address-uint256- +:xref-Governor-getVotesWithParams-address-uint256-bytes-: xref:governance.adoc#Governor-getVotesWithParams-address-uint256-bytes- +:xref-Governor-castVote-uint256-uint8-: xref:governance.adoc#Governor-castVote-uint256-uint8- +:xref-Governor-castVoteWithReason-uint256-uint8-string-: xref:governance.adoc#Governor-castVoteWithReason-uint256-uint8-string- +:xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes- +:xref-Governor-castVoteBySig-uint256-uint8-address-bytes-: xref:governance.adoc#Governor-castVoteBySig-uint256-uint8-address-bytes- +:xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-: xref:governance.adoc#Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes- +:xref-Governor-_castVote-uint256-address-uint8-string-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string- +:xref-Governor-_castVote-uint256-address-uint8-string-bytes-: xref:governance.adoc#Governor-_castVote-uint256-address-uint8-string-bytes- +:xref-Governor-relay-address-uint256-bytes-: xref:governance.adoc#Governor-relay-address-uint256-bytes- +:xref-Governor-_executor--: xref:governance.adoc#Governor-_executor-- +:xref-Governor-onERC721Received-address-address-uint256-bytes-: xref:governance.adoc#Governor-onERC721Received-address-address-uint256-bytes- +:xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-: xref:governance.adoc#Governor-onERC1155Received-address-address-uint256-uint256-bytes- +:xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-: xref:governance.adoc#Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes- +:xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-: xref:governance.adoc#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState- +:xref-Governor-_validateStateBitmap-uint256-bytes32-: xref:governance.adoc#Governor-_validateStateBitmap-uint256-bytes32- +:xref-Governor-_isValidDescriptionForProposer-address-string-: xref:governance.adoc#Governor-_isValidDescriptionForProposer-address-string- +:xref-Governor-_validateCancel-uint256-address-: xref:governance.adoc#Governor-_validateCancel-uint256-address- +:xref-Governor-clock--: xref:governance.adoc#Governor-clock-- +:xref-Governor-CLOCK_MODE--: xref:governance.adoc#Governor-CLOCK_MODE-- +:xref-Governor-votingDelay--: xref:governance.adoc#Governor-votingDelay-- +:xref-Governor-votingPeriod--: xref:governance.adoc#Governor-votingPeriod-- +:xref-Governor-quorum-uint256-: xref:governance.adoc#Governor-quorum-uint256- +:xref-Governor-BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-BALLOT_TYPEHASH-bytes32 +:xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32: xref:governance.adoc#Governor-EXTENDED_BALLOT_TYPEHASH-bytes32 +:xref-IGovernor-COUNTING_MODE--: xref:governance.adoc#IGovernor-COUNTING_MODE-- +:xref-IGovernor-hasVoted-uint256-address-: xref:governance.adoc#IGovernor-hasVoted-uint256-address- +:xref-Nonces-nonces-address-: xref:utils.adoc#Nonces-nonces-address- +:xref-Nonces-_useNonce-address-: xref:utils.adoc#Nonces-_useNonce-address- +:xref-Nonces-_useCheckedNonce-address-uint256-: xref:utils.adoc#Nonces-_useCheckedNonce-address-uint256- +:xref-EIP712-_domainSeparatorV4--: xref:utils.adoc#EIP712-_domainSeparatorV4-- +:xref-EIP712-_hashTypedDataV4-bytes32-: xref:utils.adoc#EIP712-_hashTypedDataV4-bytes32- +:xref-EIP712-eip712Domain--: xref:utils.adoc#EIP712-eip712Domain-- +:xref-EIP712-_EIP712Name--: xref:utils.adoc#EIP712-_EIP712Name-- +:xref-EIP712-_EIP712Version--: xref:utils.adoc#EIP712-_EIP712Version-- +:xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-: xref:governance.adoc#IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string- +:xref-IGovernor-ProposalQueued-uint256-uint256-: xref:governance.adoc#IGovernor-ProposalQueued-uint256-uint256- +:xref-IGovernor-ProposalExecuted-uint256-: xref:governance.adoc#IGovernor-ProposalExecuted-uint256- +:xref-IGovernor-ProposalCanceled-uint256-: xref:governance.adoc#IGovernor-ProposalCanceled-uint256- +:xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-: xref:governance.adoc#IGovernor-VoteCast-address-uint256-uint8-uint256-string- +:xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-: xref:governance.adoc#IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes- +:xref-IERC5267-EIP712DomainChanged--: xref:interfaces.adoc#IERC5267-EIP712DomainChanged-- +:xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256- +:xref-IGovernor-GovernorAlreadyCastVote-address-: xref:governance.adoc#IGovernor-GovernorAlreadyCastVote-address- +:xref-IGovernor-GovernorDisabledDeposit--: xref:governance.adoc#IGovernor-GovernorDisabledDeposit-- +:xref-IGovernor-GovernorOnlyExecutor-address-: xref:governance.adoc#IGovernor-GovernorOnlyExecutor-address- +:xref-IGovernor-GovernorNonexistentProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNonexistentProposal-uint256- +:xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-: xref:governance.adoc#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32- +:xref-IGovernor-GovernorInvalidVotingPeriod-uint256-: xref:governance.adoc#IGovernor-GovernorInvalidVotingPeriod-uint256- +:xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-: xref:governance.adoc#IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256- +:xref-IGovernor-GovernorRestrictedProposer-address-: xref:governance.adoc#IGovernor-GovernorRestrictedProposer-address- +:xref-IGovernor-GovernorInvalidVoteType--: xref:governance.adoc#IGovernor-GovernorInvalidVoteType-- +:xref-IGovernor-GovernorInvalidVoteParams--: xref:governance.adoc#IGovernor-GovernorInvalidVoteParams-- +:xref-IGovernor-GovernorQueueNotImplemented--: xref:governance.adoc#IGovernor-GovernorQueueNotImplemented-- +:xref-IGovernor-GovernorNotQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorNotQueuedProposal-uint256- +:xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-: xref:governance.adoc#IGovernor-GovernorAlreadyQueuedProposal-uint256- +:xref-IGovernor-GovernorInvalidSignature-address-: xref:governance.adoc#IGovernor-GovernorInvalidSignature-address- +:xref-IGovernor-GovernorUnableToCancel-uint256-address-: xref:governance.adoc#IGovernor-GovernorUnableToCancel-uint256-address- +:xref-Nonces-InvalidAccountNonce-address-uint256-: xref:utils.adoc#Nonces-InvalidAccountNonce-address-uint256- +:ERC20Votes: pass:normal[xref:token/ERC20.adoc#ERC20Votes[`ERC20Votes`]] +:Governor-state: pass:normal[xref:governance.adoc#Governor-state-uint256-[`Governor.state`]] :ERC721Votes: pass:normal[xref:token/ERC721.adoc#ERC721Votes[`ERC721Votes`]] :ERC721-balanceOf: pass:normal[xref:token/ERC721.adoc#ERC721-balanceOf-address-[`ERC721.balanceOf`]] :ERC721-_update: pass:normal[xref:token/ERC721.adoc#ERC721-_update-address-uint256-address-[`ERC721._update`]] @@ -1337,17 +1776,19 @@ For a written walkthrough, check out our guide on xref:ROOT:governance.adoc[How Votes modules determine the source of voting power, and sometimes quorum number. -* {GovernorVotes}: Extracts voting weight from an {ERC20Votes}, or since v4.5 an {ERC721Votes} token. +* {GovernorVotes}: Extracts voting weight from an {IVotes} contract. * {GovernorVotesQuorumFraction}: Combines with `GovernorVotes` to set the quorum as a fraction of the total token supply. +* {GovernorVotesSuperQuorumFraction}: Combines `GovernorSuperQuorum` with `GovernorVotesQuorumFraction` to set the super quorum as a fraction of the total token supply. + Counting modules determine valid voting options. * {GovernorCountingSimple}: Simple voting mechanism with 3 voting options: Against, For and Abstain. * {GovernorCountingFractional}: A more modular voting system that allows a user to vote with only part of its voting power, and to split that weight arbitrarily between the 3 different options (Against, For and Abstain). -* {GovernorCountingOverridable}: An extended version of `GovernorCountingSimple` which allows delegatees to override their delegates while the vote is live. +* {GovernorCountingOverridable}: An extended version of `GovernorCountingSimple` which allows delegatees to override their delegates while the vote is live. Must be used in conjunction with {VotesExtended}. Timelock extensions add a delay for governance decisions to be executed. The workflow is extended to require a `queue` step before execution. With these modules, proposals are executed by the external timelock contract, thus it is the timelock that has to hold the assets that are being governed. @@ -1365,6 +1806,10 @@ Other extensions can customize the behavior or interface in multiple ways. * {GovernorPreventLateQuorum}: Ensures there is a minimum voting period after quorum is reached as a security protection against large voters. +* {GovernorProposalGuardian}: Adds a proposal guardian that can cancel proposals at any stage in their lifecycle--this permission is passed on to the proposers if the guardian is not set. + +* {GovernorSuperQuorum}: Extension of {Governor} with a super quorum. Proposals that meet the super quorum (and have a majority of for votes) advance to the `Succeeded` state before the proposal deadline. + In addition to modules and extensions, the core contract requires a few virtual functions to be implemented to your particular specifications: * <>: Delay (in ERC-6372 clock) since the proposal is submitted until voting power is fixed and voting starts. This can be used to enforce a delay after a proposal is published for users to buy tokens, or delegate their votes. @@ -1379,7 +1824,6 @@ NOTE: Functions of the `Governor` contract do not include access control. If you :GovernorInvalidProposalLength: pass:normal[xref:#IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-[`++GovernorInvalidProposalLength++`]] :GovernorAlreadyCastVote: pass:normal[xref:#IGovernor-GovernorAlreadyCastVote-address-[`++GovernorAlreadyCastVote++`]] :GovernorDisabledDeposit: pass:normal[xref:#IGovernor-GovernorDisabledDeposit--[`++GovernorDisabledDeposit++`]] -:GovernorOnlyProposer: pass:normal[xref:#IGovernor-GovernorOnlyProposer-address-[`++GovernorOnlyProposer++`]] :GovernorOnlyExecutor: pass:normal[xref:#IGovernor-GovernorOnlyExecutor-address-[`++GovernorOnlyExecutor++`]] :GovernorNonexistentProposal: pass:normal[xref:#IGovernor-GovernorNonexistentProposal-uint256-[`++GovernorNonexistentProposal++`]] :GovernorUnexpectedProposalState: pass:normal[xref:#IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-[`++GovernorUnexpectedProposalState++`]] @@ -1392,6 +1836,7 @@ NOTE: Functions of the `Governor` contract do not include access control. If you :GovernorNotQueuedProposal: pass:normal[xref:#IGovernor-GovernorNotQueuedProposal-uint256-[`++GovernorNotQueuedProposal++`]] :GovernorAlreadyQueuedProposal: pass:normal[xref:#IGovernor-GovernorAlreadyQueuedProposal-uint256-[`++GovernorAlreadyQueuedProposal++`]] :GovernorInvalidSignature: pass:normal[xref:#IGovernor-GovernorInvalidSignature-address-[`++GovernorInvalidSignature++`]] +:GovernorUnableToCancel: pass:normal[xref:#IGovernor-GovernorUnableToCancel-uint256-address-[`++GovernorUnableToCancel++`]] :ProposalCreated: pass:normal[xref:#IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-[`++ProposalCreated++`]] :ProposalQueued: pass:normal[xref:#IGovernor-ProposalQueued-uint256-uint256-[`++ProposalQueued++`]] :ProposalExecuted: pass:normal[xref:#IGovernor-ProposalExecuted-uint256-[`++ProposalExecuted++`]] @@ -1402,6 +1847,7 @@ NOTE: Functions of the `Governor` contract do not include access control. If you :version: pass:normal[xref:#IGovernor-version--[`++version++`]] :COUNTING_MODE: pass:normal[xref:#IGovernor-COUNTING_MODE--[`++COUNTING_MODE++`]] :hashProposal: pass:normal[xref:#IGovernor-hashProposal-address---uint256---bytes---bytes32-[`++hashProposal++`]] +:getProposalId: pass:normal[xref:#IGovernor-getProposalId-address---uint256---bytes---bytes32-[`++getProposalId++`]] :state: pass:normal[xref:#IGovernor-state-uint256-[`++state++`]] :proposalThreshold: pass:normal[xref:#IGovernor-proposalThreshold--[`++proposalThreshold++`]] :proposalSnapshot: pass:normal[xref:#IGovernor-proposalSnapshot-uint256-[`++proposalSnapshot++`]] @@ -1425,9 +1871,37 @@ NOTE: Functions of the `Governor` contract do not include access control. If you :castVoteBySig: pass:normal[xref:#IGovernor-castVoteBySig-uint256-uint8-address-bytes-[`++castVoteBySig++`]] :castVoteWithReasonAndParamsBySig: pass:normal[xref:#IGovernor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-[`++castVoteWithReasonAndParamsBySig++`]] +:name-: pass:normal[xref:#IGovernor-name--[`++name++`]] +:version-: pass:normal[xref:#IGovernor-version--[`++version++`]] +:COUNTING_MODE-: pass:normal[xref:#IGovernor-COUNTING_MODE--[`++COUNTING_MODE++`]] +:hashProposal-address---uint256---bytes---bytes32: pass:normal[xref:#IGovernor-hashProposal-address---uint256---bytes---bytes32-[`++hashProposal++`]] +:getProposalId-address---uint256---bytes---bytes32: pass:normal[xref:#IGovernor-getProposalId-address---uint256---bytes---bytes32-[`++getProposalId++`]] +:state-uint256: pass:normal[xref:#IGovernor-state-uint256-[`++state++`]] +:proposalThreshold-: pass:normal[xref:#IGovernor-proposalThreshold--[`++proposalThreshold++`]] +:proposalSnapshot-uint256: pass:normal[xref:#IGovernor-proposalSnapshot-uint256-[`++proposalSnapshot++`]] +:proposalDeadline-uint256: pass:normal[xref:#IGovernor-proposalDeadline-uint256-[`++proposalDeadline++`]] +:proposalProposer-uint256: pass:normal[xref:#IGovernor-proposalProposer-uint256-[`++proposalProposer++`]] +:proposalEta-uint256: pass:normal[xref:#IGovernor-proposalEta-uint256-[`++proposalEta++`]] +:proposalNeedsQueuing-uint256: pass:normal[xref:#IGovernor-proposalNeedsQueuing-uint256-[`++proposalNeedsQueuing++`]] +:votingDelay-: pass:normal[xref:#IGovernor-votingDelay--[`++votingDelay++`]] +:votingPeriod-: pass:normal[xref:#IGovernor-votingPeriod--[`++votingPeriod++`]] +:quorum-uint256: pass:normal[xref:#IGovernor-quorum-uint256-[`++quorum++`]] +:getVotes-address-uint256: pass:normal[xref:#IGovernor-getVotes-address-uint256-[`++getVotes++`]] +:getVotesWithParams-address-uint256-bytes: pass:normal[xref:#IGovernor-getVotesWithParams-address-uint256-bytes-[`++getVotesWithParams++`]] +:hasVoted-uint256-address: pass:normal[xref:#IGovernor-hasVoted-uint256-address-[`++hasVoted++`]] +:propose-address---uint256---bytes---string: pass:normal[xref:#IGovernor-propose-address---uint256---bytes---string-[`++propose++`]] +:queue-address---uint256---bytes---bytes32: pass:normal[xref:#IGovernor-queue-address---uint256---bytes---bytes32-[`++queue++`]] +:execute-address---uint256---bytes---bytes32: pass:normal[xref:#IGovernor-execute-address---uint256---bytes---bytes32-[`++execute++`]] +:cancel-address---uint256---bytes---bytes32: pass:normal[xref:#IGovernor-cancel-address---uint256---bytes---bytes32-[`++cancel++`]] +:castVote-uint256-uint8: pass:normal[xref:#IGovernor-castVote-uint256-uint8-[`++castVote++`]] +:castVoteWithReason-uint256-uint8-string: pass:normal[xref:#IGovernor-castVoteWithReason-uint256-uint8-string-[`++castVoteWithReason++`]] +:castVoteWithReasonAndParams-uint256-uint8-string-bytes: pass:normal[xref:#IGovernor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-[`++castVoteWithReasonAndParams++`]] +:castVoteBySig-uint256-uint8-address-bytes: pass:normal[xref:#IGovernor-castVoteBySig-uint256-uint8-address-bytes-[`++castVoteBySig++`]] +:castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes: pass:normal[xref:#IGovernor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-[`++castVoteWithReasonAndParamsBySig++`]] + [.contract] [[IGovernor]] -=== `++IGovernor++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/IGovernor.sol[{github-icon},role=heading-link] +=== `++IGovernor++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/IGovernor.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1446,6 +1920,7 @@ Making event parameters `indexed` affects how events are decoded, potentially br * {xref-IGovernor-version--}[`++version()++`] * {xref-IGovernor-COUNTING_MODE--}[`++COUNTING_MODE()++`] * {xref-IGovernor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-IGovernor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-IGovernor-state-uint256-}[`++state(proposalId)++`] * {xref-IGovernor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-IGovernor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -1504,7 +1979,6 @@ Making event parameters `indexed` affects how events are decoded, potentially br * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -1517,6 +1991,7 @@ Making event parameters `indexed` affects how events are decoded, potentially br * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -1566,7 +2041,15 @@ JavaScript class. [[IGovernor-hashProposal-address---uint256---bytes---bytes32-]] ==== `[.contract-item-name]#++hashProposal++#++(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) → uint256++` [.item-kind]#external# -Hashing function used to (re)build the proposal id from the proposal details.. +Hashing function used to (re)build the proposal id from the proposal details. + +NOTE: For all off-chain and external calls, use {getProposalId}. + +[.contract-item] +[[IGovernor-getProposalId-address---uint256---bytes---bytes32-]] +==== `[.contract-item-name]#++getProposalId++#++(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) → uint256++` [.item-kind]#external# + +Function used to get the proposal id from the proposal details. [.contract-item] [[IGovernor-state-uint256-]] @@ -1818,12 +2301,6 @@ The vote was already cast. Token deposits are disabled in this contract. -[.contract-item] -[[IGovernor-GovernorOnlyProposer-address-]] -==== `[.contract-item-name]#++GovernorOnlyProposer++#++(address account)++` [.item-kind]#error# - -The `account` is not a proposer. - [.contract-item] [[IGovernor-GovernorOnlyExecutor-address-]] ==== `[.contract-item-name]#++GovernorOnlyExecutor++#++(address account)++` [.item-kind]#error# @@ -1904,6 +2381,12 @@ The proposal has already been queued. The provided signature is not valid for the expected `voter`. If the `voter` is a contract, the signature is not valid using {IERC1271-isValidSignature}. +[.contract-item] +[[IGovernor-GovernorUnableToCancel-uint256-address-]] +==== `[.contract-item-name]#++GovernorUnableToCancel++#++(uint256 proposalId, address account)++` [.item-kind]#error# + +The given `account` is unable to cancel the proposal with given `proposalId`. + :BALLOT_TYPEHASH: pass:normal[xref:#Governor-BALLOT_TYPEHASH-bytes32[`++BALLOT_TYPEHASH++`]] :EXTENDED_BALLOT_TYPEHASH: pass:normal[xref:#Governor-EXTENDED_BALLOT_TYPEHASH-bytes32[`++EXTENDED_BALLOT_TYPEHASH++`]] :ProposalCore: pass:normal[xref:#Governor-ProposalCore[`++ProposalCore++`]] @@ -1914,6 +2397,7 @@ If the `voter` is a contract, the signature is not valid using {IERC1271-isValid :name: pass:normal[xref:#Governor-name--[`++name++`]] :version: pass:normal[xref:#Governor-version--[`++version++`]] :hashProposal: pass:normal[xref:#Governor-hashProposal-address---uint256---bytes---bytes32-[`++hashProposal++`]] +:getProposalId: pass:normal[xref:#Governor-getProposalId-address---uint256---bytes---bytes32-[`++getProposalId++`]] :state: pass:normal[xref:#Governor-state-uint256-[`++state++`]] :proposalThreshold: pass:normal[xref:#Governor-proposalThreshold--[`++proposalThreshold++`]] :proposalSnapshot: pass:normal[xref:#Governor-proposalSnapshot-uint256-[`++proposalSnapshot++`]] @@ -1953,15 +2437,71 @@ If the `voter` is a contract, the signature is not valid using {IERC1271-isValid :_encodeStateBitmap: pass:normal[xref:#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-[`++_encodeStateBitmap++`]] :_validateStateBitmap: pass:normal[xref:#Governor-_validateStateBitmap-uint256-bytes32-[`++_validateStateBitmap++`]] :_isValidDescriptionForProposer: pass:normal[xref:#Governor-_isValidDescriptionForProposer-address-string-[`++_isValidDescriptionForProposer++`]] +:_validateCancel: pass:normal[xref:#Governor-_validateCancel-uint256-address-[`++_validateCancel++`]] :clock: pass:normal[xref:#Governor-clock--[`++clock++`]] :CLOCK_MODE: pass:normal[xref:#Governor-CLOCK_MODE--[`++CLOCK_MODE++`]] :votingDelay: pass:normal[xref:#Governor-votingDelay--[`++votingDelay++`]] :votingPeriod: pass:normal[xref:#Governor-votingPeriod--[`++votingPeriod++`]] :quorum: pass:normal[xref:#Governor-quorum-uint256-[`++quorum++`]] +:constructor-string: pass:normal[xref:#Governor-constructor-string-[`++constructor++`]] +:receive-: pass:normal[xref:#Governor-receive--[`++receive++`]] +:supportsInterface-bytes4: pass:normal[xref:#Governor-supportsInterface-bytes4-[`++supportsInterface++`]] +:name-: pass:normal[xref:#Governor-name--[`++name++`]] +:version-: pass:normal[xref:#Governor-version--[`++version++`]] +:hashProposal-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-hashProposal-address---uint256---bytes---bytes32-[`++hashProposal++`]] +:getProposalId-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-getProposalId-address---uint256---bytes---bytes32-[`++getProposalId++`]] +:state-uint256: pass:normal[xref:#Governor-state-uint256-[`++state++`]] +:proposalThreshold-: pass:normal[xref:#Governor-proposalThreshold--[`++proposalThreshold++`]] +:proposalSnapshot-uint256: pass:normal[xref:#Governor-proposalSnapshot-uint256-[`++proposalSnapshot++`]] +:proposalDeadline-uint256: pass:normal[xref:#Governor-proposalDeadline-uint256-[`++proposalDeadline++`]] +:proposalProposer-uint256: pass:normal[xref:#Governor-proposalProposer-uint256-[`++proposalProposer++`]] +:proposalEta-uint256: pass:normal[xref:#Governor-proposalEta-uint256-[`++proposalEta++`]] +:proposalNeedsQueuing-uint256: pass:normal[xref:#Governor-proposalNeedsQueuing-uint256-[`++proposalNeedsQueuing++`]] +:_checkGovernance-: pass:normal[xref:#Governor-_checkGovernance--[`++_checkGovernance++`]] +:_quorumReached-uint256: pass:normal[xref:#Governor-_quorumReached-uint256-[`++_quorumReached++`]] +:_voteSucceeded-uint256: pass:normal[xref:#Governor-_voteSucceeded-uint256-[`++_voteSucceeded++`]] +:_getVotes-address-uint256-bytes: pass:normal[xref:#Governor-_getVotes-address-uint256-bytes-[`++_getVotes++`]] +:_countVote-uint256-address-uint8-uint256-bytes: pass:normal[xref:#Governor-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] +:_tallyUpdated-uint256: pass:normal[xref:#Governor-_tallyUpdated-uint256-[`++_tallyUpdated++`]] +:_defaultParams-: pass:normal[xref:#Governor-_defaultParams--[`++_defaultParams++`]] +:propose-address---uint256---bytes---string: pass:normal[xref:#Governor-propose-address---uint256---bytes---string-[`++propose++`]] +:_propose-address---uint256---bytes---string-address: pass:normal[xref:#Governor-_propose-address---uint256---bytes---string-address-[`++_propose++`]] +:queue-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-queue-address---uint256---bytes---bytes32-[`++queue++`]] +:_queueOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-[`++_queueOperations++`]] +:execute-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-execute-address---uint256---bytes---bytes32-[`++execute++`]] +:_executeOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-[`++_executeOperations++`]] +:cancel-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-cancel-address---uint256---bytes---bytes32-[`++cancel++`]] +:_cancel-address---uint256---bytes---bytes32: pass:normal[xref:#Governor-_cancel-address---uint256---bytes---bytes32-[`++_cancel++`]] +:getVotes-address-uint256: pass:normal[xref:#Governor-getVotes-address-uint256-[`++getVotes++`]] +:getVotesWithParams-address-uint256-bytes: pass:normal[xref:#Governor-getVotesWithParams-address-uint256-bytes-[`++getVotesWithParams++`]] +:castVote-uint256-uint8: pass:normal[xref:#Governor-castVote-uint256-uint8-[`++castVote++`]] +:castVoteWithReason-uint256-uint8-string: pass:normal[xref:#Governor-castVoteWithReason-uint256-uint8-string-[`++castVoteWithReason++`]] +:castVoteWithReasonAndParams-uint256-uint8-string-bytes: pass:normal[xref:#Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-[`++castVoteWithReasonAndParams++`]] +:castVoteBySig-uint256-uint8-address-bytes: pass:normal[xref:#Governor-castVoteBySig-uint256-uint8-address-bytes-[`++castVoteBySig++`]] +:castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes: pass:normal[xref:#Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-[`++castVoteWithReasonAndParamsBySig++`]] +:_castVote-uint256-address-uint8-string: pass:normal[xref:#Governor-_castVote-uint256-address-uint8-string-[`++_castVote++`]] +:_castVote-uint256-address-uint8-string-bytes: pass:normal[xref:#Governor-_castVote-uint256-address-uint8-string-bytes-[`++_castVote++`]] +:relay-address-uint256-bytes: pass:normal[xref:#Governor-relay-address-uint256-bytes-[`++relay++`]] +:_executor-: pass:normal[xref:#Governor-_executor--[`++_executor++`]] +:onERC721Received-address-address-uint256-bytes: pass:normal[xref:#Governor-onERC721Received-address-address-uint256-bytes-[`++onERC721Received++`]] +:onERC1155Received-address-address-uint256-uint256-bytes: pass:normal[xref:#Governor-onERC1155Received-address-address-uint256-uint256-bytes-[`++onERC1155Received++`]] +:onERC1155BatchReceived-address-address-uint256---uint256---bytes: pass:normal[xref:#Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`++onERC1155BatchReceived++`]] +:_encodeStateBitmap-enum-IGovernor-ProposalState: pass:normal[xref:#Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-[`++_encodeStateBitmap++`]] +:_validateStateBitmap-uint256-bytes32: pass:normal[xref:#Governor-_validateStateBitmap-uint256-bytes32-[`++_validateStateBitmap++`]] +:_isValidDescriptionForProposer-address-string: pass:normal[xref:#Governor-_isValidDescriptionForProposer-address-string-[`++_isValidDescriptionForProposer++`]] +:_validateCancel-uint256-address: pass:normal[xref:#Governor-_validateCancel-uint256-address-[`++_validateCancel++`]] +:clock-: pass:normal[xref:#Governor-clock--[`++clock++`]] +:CLOCK_MODE-: pass:normal[xref:#Governor-CLOCK_MODE--[`++CLOCK_MODE++`]] +:votingDelay-: pass:normal[xref:#Governor-votingDelay--[`++votingDelay++`]] +:votingPeriod-: pass:normal[xref:#Governor-votingPeriod--[`++votingPeriod++`]] +:quorum-uint256: pass:normal[xref:#Governor-quorum-uint256-[`++quorum++`]] +:BALLOT_TYPEHASH-bytes32: pass:normal[xref:#Governor-BALLOT_TYPEHASH-bytes32[`++BALLOT_TYPEHASH++`]] +:EXTENDED_BALLOT_TYPEHASH-bytes32: pass:normal[xref:#Governor-EXTENDED_BALLOT_TYPEHASH-bytes32[`++EXTENDED_BALLOT_TYPEHASH++`]] + [.contract] [[Governor]] -=== `++Governor++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/Governor.sol[{github-icon},role=heading-link] +=== `++Governor++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/Governor.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1972,9 +2512,9 @@ Core of the governance system, designed to be extended through various modules. This contract is abstract and requires several functions to be implemented in various modules: -- A counting module must implement {quorum}, {_quorumReached}, {_voteSucceeded} and {_countVote} +- A counting module must implement {_quorumReached}, {_voteSucceeded} and {_countVote} - A voting module must implement {_getVotes} -- Additionally, {votingPeriod} must also be implemented +- Additionally, {votingPeriod}, {votingDelay}, and {quorum} must also be implemented [.contract-index] .Modifiers @@ -1991,6 +2531,7 @@ This contract is abstract and requires several functions to be implemented in va * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -2030,6 +2571,7 @@ This contract is abstract and requires several functions to be implemented in va * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -2132,7 +2674,6 @@ This contract is abstract and requires several functions to be implemented in va * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -2145,6 +2686,7 @@ This contract is abstract and requires several functions to be implemented in va * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -2226,6 +2768,12 @@ same proposal (with same operation and same description) will have the same id i across multiple networks. This also means that in order to execute the same operation twice (on the same governor) the proposer will have to change the description in order to avoid proposal id conflicts. +[.contract-item] +[[Governor-getProposalId-address---uint256---bytes---bytes32-]] +==== `[.contract-item-name]#++getProposalId++#++(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) → uint256++` [.item-kind]#public# + +See {IGovernor-getProposalId}. + [.contract-item] [[Governor-state-uint256-]] ==== `[.contract-item-name]#++state++#++(uint256 proposalId) → enum IGovernor.ProposalState++` [.item-kind]#public# @@ -2369,7 +2917,7 @@ Internal execution mechanism. Can be overridden (without a super call) to modify performed (for example adding a vault/timelock). NOTE: Calling this function directly will NOT check the current state of the proposal, set the executed flag to -true or emit the `ProposalExecuted` event. Executing a proposal should be done using {execute} or {_execute}. +true or emit the `ProposalExecuted` event. Executing a proposal should be done using {execute}. [.contract-item] [[Governor-cancel-address---uint256---bytes---bytes32-]] @@ -2511,6 +3059,14 @@ If requirements are not met, reverts with a {GovernorUnexpectedProposalState} er [[Governor-_isValidDescriptionForProposer-address-string-]] ==== `[.contract-item-name]#++_isValidDescriptionForProposer++#++(address proposer, string description) → bool++` [.item-kind]#internal# +[.contract-item] +[[Governor-_validateCancel-uint256-address-]] +==== `[.contract-item-name]#++_validateCancel++#++(uint256 proposalId, address caller) → bool++` [.item-kind]#internal# + +Check if the `caller` can cancel the proposal with the given `proposalId`. + +The default implementation allows the proposal proposer to cancel the proposal during the pending state. + [.contract-item] [[Governor-clock--]] ==== `[.contract-item-name]#++clock++#++() → uint48++` [.item-kind]#public# @@ -2578,9 +3134,16 @@ quorum depending on values such as the totalSupply of a token at this timepoint :_voteSucceeded: pass:normal[xref:#GovernorCountingSimple-_voteSucceeded-uint256-[`++_voteSucceeded++`]] :_countVote: pass:normal[xref:#GovernorCountingSimple-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] +:COUNTING_MODE-: pass:normal[xref:#GovernorCountingSimple-COUNTING_MODE--[`++COUNTING_MODE++`]] +:hasVoted-uint256-address: pass:normal[xref:#GovernorCountingSimple-hasVoted-uint256-address-[`++hasVoted++`]] +:proposalVotes-uint256: pass:normal[xref:#GovernorCountingSimple-proposalVotes-uint256-[`++proposalVotes++`]] +:_quorumReached-uint256: pass:normal[xref:#GovernorCountingSimple-_quorumReached-uint256-[`++_quorumReached++`]] +:_voteSucceeded-uint256: pass:normal[xref:#GovernorCountingSimple-_voteSucceeded-uint256-[`++_voteSucceeded++`]] +:_countVote-uint256-address-uint8-uint256-bytes: pass:normal[xref:#GovernorCountingSimple-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] + [.contract] [[GovernorCountingSimple]] -=== `++GovernorCountingSimple++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorCountingSimple.sol[{github-icon},role=heading-link] +=== `++GovernorCountingSimple++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorCountingSimple.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2606,6 +3169,7 @@ Extension of {Governor} for simple, 3 options, vote counting. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -2642,6 +3206,7 @@ Extension of {Governor} for simple, 3 options, vote counting. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -2748,7 +3313,6 @@ Extension of {Governor} for simple, 3 options, vote counting. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -2761,6 +3325,7 @@ Extension of {Governor} for simple, 3 options, vote counting. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -2830,9 +3395,17 @@ See {Governor-_countVote}. In this module, the support follows the `VoteType` en :_voteSucceeded: pass:normal[xref:#GovernorCountingFractional-_voteSucceeded-uint256-[`++_voteSucceeded++`]] :_countVote: pass:normal[xref:#GovernorCountingFractional-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] +:COUNTING_MODE-: pass:normal[xref:#GovernorCountingFractional-COUNTING_MODE--[`++COUNTING_MODE++`]] +:hasVoted-uint256-address: pass:normal[xref:#GovernorCountingFractional-hasVoted-uint256-address-[`++hasVoted++`]] +:usedVotes-uint256-address: pass:normal[xref:#GovernorCountingFractional-usedVotes-uint256-address-[`++usedVotes++`]] +:proposalVotes-uint256: pass:normal[xref:#GovernorCountingFractional-proposalVotes-uint256-[`++proposalVotes++`]] +:_quorumReached-uint256: pass:normal[xref:#GovernorCountingFractional-_quorumReached-uint256-[`++_quorumReached++`]] +:_voteSucceeded-uint256: pass:normal[xref:#GovernorCountingFractional-_voteSucceeded-uint256-[`++_voteSucceeded++`]] +:_countVote-uint256-address-uint8-uint256-bytes: pass:normal[xref:#GovernorCountingFractional-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] + [.contract] [[GovernorCountingFractional]] -=== `++GovernorCountingFractional++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorCountingFractional.sol[{github-icon},role=heading-link] +=== `++GovernorCountingFractional++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorCountingFractional.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2858,7 +3431,7 @@ Some example use cases include: * Voting from an L2 with tokens held by a bridge * Voting privately from a shielded pool using zero knowledge proofs. -Based on ScopeLift's GovernorCountingFractional[https://github.com/ScopeLift/flexible-voting/blob/e5de2efd1368387b840931f19f3c184c85842761/src/GovernorCountingFractional.sol] +Based on ScopeLift's https://github.com/ScopeLift/flexible-voting/blob/e5de2efd1368387b840931f19f3c184c85842761/src/GovernorCountingFractional.sol[`GovernorCountingFractional`] _Available since v5.1._ @@ -2880,6 +3453,7 @@ _Available since v5.1._ * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -2916,6 +3490,7 @@ _Available since v5.1._ * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -3023,7 +3598,6 @@ _Available since v5.1._ * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -3036,6 +3610,7 @@ _Available since v5.1._ * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -3158,9 +3733,9 @@ their checkpointed total weight minus votes already cast on the proposal). This `abi.encodePacked(uint128(againstVotes), uint128(forVotes), uint128(abstainVotes))` -NOTE: Consider that fractional voting restricts the number of casted vote (in each category) to 128 bits. +NOTE: Consider that fractional voting restricts the number of casted votes (in each category) to 128 bits. Depending on how many decimals the underlying token has, a single voter may require to split their vote into -multiple vote operations. For precision higher than ~30 decimals, large token holders may require an +multiple vote operations. For precision higher than ~30 decimals, large token holders may require a potentially large number of calls to cast all their votes. The voter has the possibility to cast all the remaining votes in a single operation using the traditional "bravo" vote. @@ -3174,15 +3749,376 @@ A fractional vote params uses more votes than are available for that user. [[GovernorCountingFractional-VOTE_TYPE_FRACTIONAL-uint8]] ==== `uint8 [.contract-item-name]#++VOTE_TYPE_FRACTIONAL++#` [.item-kind]#internal constant# +:OVERRIDE_BALLOT_TYPEHASH: pass:normal[xref:#GovernorCountingOverridable-OVERRIDE_BALLOT_TYPEHASH-bytes32[`++OVERRIDE_BALLOT_TYPEHASH++`]] +:VoteType: pass:normal[xref:#GovernorCountingOverridable-VoteType[`++VoteType++`]] +:VoteReceipt: pass:normal[xref:#GovernorCountingOverridable-VoteReceipt[`++VoteReceipt++`]] +:ProposalVote: pass:normal[xref:#GovernorCountingOverridable-ProposalVote[`++ProposalVote++`]] +:VoteReduced: pass:normal[xref:#GovernorCountingOverridable-VoteReduced-address-uint256-uint8-uint256-[`++VoteReduced++`]] +:OverrideVoteCast: pass:normal[xref:#GovernorCountingOverridable-OverrideVoteCast-address-uint256-uint8-uint256-string-[`++OverrideVoteCast++`]] +:GovernorAlreadyOverriddenVote: pass:normal[xref:#GovernorCountingOverridable-GovernorAlreadyOverriddenVote-address-[`++GovernorAlreadyOverriddenVote++`]] +:COUNTING_MODE: pass:normal[xref:#GovernorCountingOverridable-COUNTING_MODE--[`++COUNTING_MODE++`]] +:hasVoted: pass:normal[xref:#GovernorCountingOverridable-hasVoted-uint256-address-[`++hasVoted++`]] +:hasVotedOverride: pass:normal[xref:#GovernorCountingOverridable-hasVotedOverride-uint256-address-[`++hasVotedOverride++`]] +:proposalVotes: pass:normal[xref:#GovernorCountingOverridable-proposalVotes-uint256-[`++proposalVotes++`]] +:_quorumReached: pass:normal[xref:#GovernorCountingOverridable-_quorumReached-uint256-[`++_quorumReached++`]] +:_voteSucceeded: pass:normal[xref:#GovernorCountingOverridable-_voteSucceeded-uint256-[`++_voteSucceeded++`]] +:_countVote: pass:normal[xref:#GovernorCountingOverridable-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] +:_countOverride: pass:normal[xref:#GovernorCountingOverridable-_countOverride-uint256-address-uint8-[`++_countOverride++`]] +:_castOverride: pass:normal[xref:#GovernorCountingOverridable-_castOverride-uint256-address-uint8-string-[`++_castOverride++`]] +:castOverrideVote: pass:normal[xref:#GovernorCountingOverridable-castOverrideVote-uint256-uint8-string-[`++castOverrideVote++`]] +:castOverrideVoteBySig: pass:normal[xref:#GovernorCountingOverridable-castOverrideVoteBySig-uint256-uint8-address-string-bytes-[`++castOverrideVoteBySig++`]] + +:COUNTING_MODE-: pass:normal[xref:#GovernorCountingOverridable-COUNTING_MODE--[`++COUNTING_MODE++`]] +:hasVoted-uint256-address: pass:normal[xref:#GovernorCountingOverridable-hasVoted-uint256-address-[`++hasVoted++`]] +:hasVotedOverride-uint256-address: pass:normal[xref:#GovernorCountingOverridable-hasVotedOverride-uint256-address-[`++hasVotedOverride++`]] +:proposalVotes-uint256: pass:normal[xref:#GovernorCountingOverridable-proposalVotes-uint256-[`++proposalVotes++`]] +:_quorumReached-uint256: pass:normal[xref:#GovernorCountingOverridable-_quorumReached-uint256-[`++_quorumReached++`]] +:_voteSucceeded-uint256: pass:normal[xref:#GovernorCountingOverridable-_voteSucceeded-uint256-[`++_voteSucceeded++`]] +:_countVote-uint256-address-uint8-uint256-bytes: pass:normal[xref:#GovernorCountingOverridable-_countVote-uint256-address-uint8-uint256-bytes-[`++_countVote++`]] +:_countOverride-uint256-address-uint8: pass:normal[xref:#GovernorCountingOverridable-_countOverride-uint256-address-uint8-[`++_countOverride++`]] +:_castOverride-uint256-address-uint8-string: pass:normal[xref:#GovernorCountingOverridable-_castOverride-uint256-address-uint8-string-[`++_castOverride++`]] +:castOverrideVote-uint256-uint8-string: pass:normal[xref:#GovernorCountingOverridable-castOverrideVote-uint256-uint8-string-[`++castOverrideVote++`]] +:castOverrideVoteBySig-uint256-uint8-address-string-bytes: pass:normal[xref:#GovernorCountingOverridable-castOverrideVoteBySig-uint256-uint8-address-string-bytes-[`++castOverrideVoteBySig++`]] +:OVERRIDE_BALLOT_TYPEHASH-bytes32: pass:normal[xref:#GovernorCountingOverridable-OVERRIDE_BALLOT_TYPEHASH-bytes32[`++OVERRIDE_BALLOT_TYPEHASH++`]] + +[.contract] +[[GovernorCountingOverridable]] +=== `++GovernorCountingOverridable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorCountingOverridable.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/governance/extensions/GovernorCountingOverridable.sol"; +``` + +Extension of {Governor} which enables delegators to override the vote of their delegates. This module requires a +token that inherits {VotesExtended}. + +[.contract-index] +.Functions +-- +* {xref-GovernorCountingOverridable-COUNTING_MODE--}[`++COUNTING_MODE()++`] +* {xref-GovernorCountingOverridable-hasVoted-uint256-address-}[`++hasVoted(proposalId, account)++`] +* {xref-GovernorCountingOverridable-hasVotedOverride-uint256-address-}[`++hasVotedOverride(proposalId, account)++`] +* {xref-GovernorCountingOverridable-proposalVotes-uint256-}[`++proposalVotes(proposalId)++`] +* {xref-GovernorCountingOverridable-_quorumReached-uint256-}[`++_quorumReached(proposalId)++`] +* {xref-GovernorCountingOverridable-_voteSucceeded-uint256-}[`++_voteSucceeded(proposalId)++`] +* {xref-GovernorCountingOverridable-_countVote-uint256-address-uint8-uint256-bytes-}[`++_countVote(proposalId, account, support, totalWeight, )++`] +* {xref-GovernorCountingOverridable-_countOverride-uint256-address-uint8-}[`++_countOverride(proposalId, account, support)++`] +* {xref-GovernorCountingOverridable-_castOverride-uint256-address-uint8-string-}[`++_castOverride(proposalId, account, support, reason)++`] +* {xref-GovernorCountingOverridable-castOverrideVote-uint256-uint8-string-}[`++castOverrideVote(proposalId, support, reason)++`] +* {xref-GovernorCountingOverridable-castOverrideVoteBySig-uint256-uint8-address-string-bytes-}[`++castOverrideVoteBySig(proposalId, support, voter, reason, signature)++`] +* {xref-GovernorCountingOverridable-OVERRIDE_BALLOT_TYPEHASH-bytes32}[`++OVERRIDE_BALLOT_TYPEHASH()++`] + +[.contract-subindex-inherited] +.GovernorVotes +* {xref-GovernorVotes-token--}[`++token()++`] +* {xref-GovernorVotes-clock--}[`++clock()++`] +* {xref-GovernorVotes-CLOCK_MODE--}[`++CLOCK_MODE()++`] +* {xref-GovernorVotes-_getVotes-address-uint256-bytes-}[`++_getVotes(account, timepoint, )++`] + +[.contract-subindex-inherited] +.Governor +* {xref-Governor-receive--}[`++receive()++`] +* {xref-Governor-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-Governor-name--}[`++name()++`] +* {xref-Governor-version--}[`++version()++`] +* {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-state-uint256-}[`++state(proposalId)++`] +* {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] +* {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] +* {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] +* {xref-Governor-proposalProposer-uint256-}[`++proposalProposer(proposalId)++`] +* {xref-Governor-proposalEta-uint256-}[`++proposalEta(proposalId)++`] +* {xref-Governor-proposalNeedsQueuing-uint256-}[`++proposalNeedsQueuing()++`] +* {xref-Governor-_checkGovernance--}[`++_checkGovernance()++`] +* {xref-Governor-_tallyUpdated-uint256-}[`++_tallyUpdated(proposalId)++`] +* {xref-Governor-_defaultParams--}[`++_defaultParams()++`] +* {xref-Governor-propose-address---uint256---bytes---string-}[`++propose(targets, values, calldatas, description)++`] +* {xref-Governor-_propose-address---uint256---bytes---string-address-}[`++_propose(targets, values, calldatas, description, proposer)++`] +* {xref-Governor-queue-address---uint256---bytes---bytes32-}[`++queue(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-}[`++_queueOperations(, , , , )++`] +* {xref-Governor-execute-address---uint256---bytes---bytes32-}[`++execute(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-}[`++_executeOperations(, targets, values, calldatas, )++`] +* {xref-Governor-cancel-address---uint256---bytes---bytes32-}[`++cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_cancel-address---uint256---bytes---bytes32-}[`++_cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getVotes-address-uint256-}[`++getVotes(account, timepoint)++`] +* {xref-Governor-getVotesWithParams-address-uint256-bytes-}[`++getVotesWithParams(account, timepoint, params)++`] +* {xref-Governor-castVote-uint256-uint8-}[`++castVote(proposalId, support)++`] +* {xref-Governor-castVoteWithReason-uint256-uint8-string-}[`++castVoteWithReason(proposalId, support, reason)++`] +* {xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-}[`++castVoteWithReasonAndParams(proposalId, support, reason, params)++`] +* {xref-Governor-castVoteBySig-uint256-uint8-address-bytes-}[`++castVoteBySig(proposalId, support, voter, signature)++`] +* {xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-}[`++castVoteWithReasonAndParamsBySig(proposalId, support, voter, reason, params, signature)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-}[`++_castVote(proposalId, account, support, reason)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-bytes-}[`++_castVote(proposalId, account, support, reason, params)++`] +* {xref-Governor-relay-address-uint256-bytes-}[`++relay(target, value, data)++`] +* {xref-Governor-_executor--}[`++_executor()++`] +* {xref-Governor-onERC721Received-address-address-uint256-bytes-}[`++onERC721Received(, , , )++`] +* {xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-}[`++onERC1155Received(, , , , )++`] +* {xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-}[`++onERC1155BatchReceived(, , , , )++`] +* {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] +* {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] +* {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] +* {xref-Governor-votingDelay--}[`++votingDelay()++`] +* {xref-Governor-votingPeriod--}[`++votingPeriod()++`] +* {xref-Governor-quorum-uint256-}[`++quorum(timepoint)++`] +* {xref-Governor-BALLOT_TYPEHASH-bytes32}[`++BALLOT_TYPEHASH()++`] +* {xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32}[`++EXTENDED_BALLOT_TYPEHASH()++`] + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-nonces-address-}[`++nonces(owner)++`] +* {xref-Nonces-_useNonce-address-}[`++_useNonce(owner)++`] +* {xref-Nonces-_useCheckedNonce-address-uint256-}[`++_useCheckedNonce(owner, nonce)++`] + +[.contract-subindex-inherited] +.EIP712 +* {xref-EIP712-_domainSeparatorV4--}[`++_domainSeparatorV4()++`] +* {xref-EIP712-_hashTypedDataV4-bytes32-}[`++_hashTypedDataV4(structHash)++`] +* {xref-EIP712-eip712Domain--}[`++eip712Domain()++`] +* {xref-EIP712-_EIP712Name--}[`++_EIP712Name()++`] +* {xref-EIP712-_EIP712Version--}[`++_EIP712Version()++`] + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- +* {xref-GovernorCountingOverridable-VoteReduced-address-uint256-uint8-uint256-}[`++VoteReduced(delegate, proposalId, support, weight)++`] +* {xref-GovernorCountingOverridable-OverrideVoteCast-address-uint256-uint8-uint256-string-}[`++OverrideVoteCast(voter, proposalId, support, weight, reason)++`] + +[.contract-subindex-inherited] +.GovernorVotes + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-}[`++ProposalCreated(proposalId, proposer, targets, values, signatures, calldatas, voteStart, voteEnd, description)++`] +* {xref-IGovernor-ProposalQueued-uint256-uint256-}[`++ProposalQueued(proposalId, etaSeconds)++`] +* {xref-IGovernor-ProposalExecuted-uint256-}[`++ProposalExecuted(proposalId)++`] +* {xref-IGovernor-ProposalCanceled-uint256-}[`++ProposalCanceled(proposalId)++`] +* {xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-}[`++VoteCast(voter, proposalId, support, weight, reason)++`] +* {xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-}[`++VoteCastWithParams(voter, proposalId, support, weight, reason, params)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 +* {xref-IERC5267-EIP712DomainChanged--}[`++EIP712DomainChanged()++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- +* {xref-GovernorCountingOverridable-GovernorAlreadyOverriddenVote-address-}[`++GovernorAlreadyOverriddenVote(account)++`] + +[.contract-subindex-inherited] +.GovernorVotes + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] +* {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] +* {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] +* {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] +* {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] +* {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] +* {xref-IGovernor-GovernorInvalidVotingPeriod-uint256-}[`++GovernorInvalidVotingPeriod(votingPeriod)++`] +* {xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-}[`++GovernorInsufficientProposerVotes(proposer, votes, threshold)++`] +* {xref-IGovernor-GovernorRestrictedProposer-address-}[`++GovernorRestrictedProposer(proposer)++`] +* {xref-IGovernor-GovernorInvalidVoteType--}[`++GovernorInvalidVoteType()++`] +* {xref-IGovernor-GovernorInvalidVoteParams--}[`++GovernorInvalidVoteParams()++`] +* {xref-IGovernor-GovernorQueueNotImplemented--}[`++GovernorQueueNotImplemented()++`] +* {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-InvalidAccountNonce-address-uint256-}[`++InvalidAccountNonce(account, currentNonce)++`] + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[GovernorCountingOverridable-COUNTING_MODE--]] +==== `[.contract-item-name]#++COUNTING_MODE++#++() → string++` [.item-kind]#public# + +See {IGovernor-COUNTING_MODE}. + +[.contract-item] +[[GovernorCountingOverridable-hasVoted-uint256-address-]] +==== `[.contract-item-name]#++hasVoted++#++(uint256 proposalId, address account) → bool++` [.item-kind]#public# + +See {IGovernor-hasVoted}. + +NOTE: Calling {castVote} (or similar) casts a vote using the voting power that is delegated to the voter. +Conversely, calling {castOverrideVote} (or similar) uses the voting power of the account itself, from its asset +balances. Casting an "override vote" does not count as voting and won't be reflected by this getter. Consider +using {hasVotedOverride} to check if an account has casted an "override vote" for a given proposal id. + +[.contract-item] +[[GovernorCountingOverridable-hasVotedOverride-uint256-address-]] +==== `[.contract-item-name]#++hasVotedOverride++#++(uint256 proposalId, address account) → bool++` [.item-kind]#public# + +Check if an `account` has overridden their delegate for a proposal. + +[.contract-item] +[[GovernorCountingOverridable-proposalVotes-uint256-]] +==== `[.contract-item-name]#++proposalVotes++#++(uint256 proposalId) → uint256 againstVotes, uint256 forVotes, uint256 abstainVotes++` [.item-kind]#public# + +Accessor to the internal vote counts. + +[.contract-item] +[[GovernorCountingOverridable-_quorumReached-uint256-]] +==== `[.contract-item-name]#++_quorumReached++#++(uint256 proposalId) → bool++` [.item-kind]#internal# + +See {Governor-_quorumReached}. + +[.contract-item] +[[GovernorCountingOverridable-_voteSucceeded-uint256-]] +==== `[.contract-item-name]#++_voteSucceeded++#++(uint256 proposalId) → bool++` [.item-kind]#internal# + +See {Governor-_voteSucceeded}. In this module, the forVotes must be strictly over the againstVotes. + +[.contract-item] +[[GovernorCountingOverridable-_countVote-uint256-address-uint8-uint256-bytes-]] +==== `[.contract-item-name]#++_countVote++#++(uint256 proposalId, address account, uint8 support, uint256 totalWeight, bytes) → uint256++` [.item-kind]#internal# + +See {Governor-_countVote}. In this module, the support follows the `VoteType` enum (from Governor Bravo). + +NOTE: called by {Governor-_castVote} which emits the {IGovernor-VoteCast} (or {IGovernor-VoteCastWithParams}) +event. + +[.contract-item] +[[GovernorCountingOverridable-_countOverride-uint256-address-uint8-]] +==== `[.contract-item-name]#++_countOverride++#++(uint256 proposalId, address account, uint8 support) → uint256++` [.item-kind]#internal# + +Variant of {Governor-_countVote} that deals with vote overrides. + +NOTE: See {hasVoted} for more details about the difference between {castVote} and {castOverrideVote}. + +[.contract-item] +[[GovernorCountingOverridable-_castOverride-uint256-address-uint8-string-]] +==== `[.contract-item-name]#++_castOverride++#++(uint256 proposalId, address account, uint8 support, string reason) → uint256++` [.item-kind]#internal# + +Variant of {Governor-_castVote} that deals with vote overrides. Returns the overridden weight. + +[.contract-item] +[[GovernorCountingOverridable-castOverrideVote-uint256-uint8-string-]] +==== `[.contract-item-name]#++castOverrideVote++#++(uint256 proposalId, uint8 support, string reason) → uint256++` [.item-kind]#public# + +Public function for casting an override vote. Returns the overridden weight. + +[.contract-item] +[[GovernorCountingOverridable-castOverrideVoteBySig-uint256-uint8-address-string-bytes-]] +==== `[.contract-item-name]#++castOverrideVoteBySig++#++(uint256 proposalId, uint8 support, address voter, string reason, bytes signature) → uint256++` [.item-kind]#public# + +Public function for casting an override vote using a voter's signature. Returns the overridden weight. + +[.contract-item] +[[GovernorCountingOverridable-OVERRIDE_BALLOT_TYPEHASH-bytes32]] +==== `[.contract-item-name]#++OVERRIDE_BALLOT_TYPEHASH++#++() → bytes32++` [.item-kind]#public# + +[.contract-item] +[[GovernorCountingOverridable-VoteReduced-address-uint256-uint8-uint256-]] +==== `[.contract-item-name]#++VoteReduced++#++(address indexed delegate, uint256 proposalId, uint8 support, uint256 weight)++` [.item-kind]#event# + +The votes casted by `delegate` were reduced by `weight` after an override vote was casted by the original token holder + +[.contract-item] +[[GovernorCountingOverridable-OverrideVoteCast-address-uint256-uint8-uint256-string-]] +==== `[.contract-item-name]#++OverrideVoteCast++#++(address indexed voter, uint256 proposalId, uint8 support, uint256 weight, string reason)++` [.item-kind]#event# + +A delegated vote on `proposalId` was overridden by `weight` + +[.contract-item] +[[GovernorCountingOverridable-GovernorAlreadyOverriddenVote-address-]] +==== `[.contract-item-name]#++GovernorAlreadyOverriddenVote++#++(address account)++` [.item-kind]#error# + :constructor: pass:normal[xref:#GovernorVotes-constructor-contract-IVotes-[`++constructor++`]] :token: pass:normal[xref:#GovernorVotes-token--[`++token++`]] :clock: pass:normal[xref:#GovernorVotes-clock--[`++clock++`]] :CLOCK_MODE: pass:normal[xref:#GovernorVotes-CLOCK_MODE--[`++CLOCK_MODE++`]] :_getVotes: pass:normal[xref:#GovernorVotes-_getVotes-address-uint256-bytes-[`++_getVotes++`]] +:constructor-contract-IVotes: pass:normal[xref:#GovernorVotes-constructor-contract-IVotes-[`++constructor++`]] +:token-: pass:normal[xref:#GovernorVotes-token--[`++token++`]] +:clock-: pass:normal[xref:#GovernorVotes-clock--[`++clock++`]] +:CLOCK_MODE-: pass:normal[xref:#GovernorVotes-CLOCK_MODE--[`++CLOCK_MODE++`]] +:_getVotes-address-uint256-bytes: pass:normal[xref:#GovernorVotes-_getVotes-address-uint256-bytes-[`++_getVotes++`]] + [.contract] [[GovernorVotes]] -=== `++GovernorVotes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorVotes.sol[{github-icon},role=heading-link] +=== `++GovernorVotes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorVotes.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3208,6 +4144,7 @@ token. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -3246,6 +4183,7 @@ token. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] * {xref-Governor-votingPeriod--}[`++votingPeriod()++`] * {xref-Governor-quorum-uint256-}[`++quorum(timepoint)++`] @@ -3352,7 +4290,6 @@ token. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -3365,6 +4302,7 @@ token. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -3423,10 +4361,20 @@ Machine-readable description of the clock as specified in ERC-6372. :quorum: pass:normal[xref:#GovernorVotesQuorumFraction-quorum-uint256-[`++quorum++`]] :updateQuorumNumerator: pass:normal[xref:#GovernorVotesQuorumFraction-updateQuorumNumerator-uint256-[`++updateQuorumNumerator++`]] :_updateQuorumNumerator: pass:normal[xref:#GovernorVotesQuorumFraction-_updateQuorumNumerator-uint256-[`++_updateQuorumNumerator++`]] +:_optimisticUpperLookupRecent: pass:normal[xref:#GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-[`++_optimisticUpperLookupRecent++`]] + +:constructor-uint256: pass:normal[xref:#GovernorVotesQuorumFraction-constructor-uint256-[`++constructor++`]] +:quorumNumerator-: pass:normal[xref:#GovernorVotesQuorumFraction-quorumNumerator--[`++quorumNumerator++`]] +:quorumNumerator-uint256: pass:normal[xref:#GovernorVotesQuorumFraction-quorumNumerator-uint256-[`++quorumNumerator++`]] +:quorumDenominator-: pass:normal[xref:#GovernorVotesQuorumFraction-quorumDenominator--[`++quorumDenominator++`]] +:quorum-uint256: pass:normal[xref:#GovernorVotesQuorumFraction-quorum-uint256-[`++quorum++`]] +:updateQuorumNumerator-uint256: pass:normal[xref:#GovernorVotesQuorumFraction-updateQuorumNumerator-uint256-[`++updateQuorumNumerator++`]] +:_updateQuorumNumerator-uint256: pass:normal[xref:#GovernorVotesQuorumFraction-_updateQuorumNumerator-uint256-[`++_updateQuorumNumerator++`]] +:_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256: pass:normal[xref:#GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-[`++_optimisticUpperLookupRecent++`]] [.contract] [[GovernorVotesQuorumFraction]] -=== `++GovernorVotesQuorumFraction++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorVotesQuorumFraction.sol[{github-icon},role=heading-link] +=== `++GovernorVotesQuorumFraction++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorVotesQuorumFraction.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3446,6 +4394,7 @@ fraction of the total supply. * {xref-GovernorVotesQuorumFraction-quorum-uint256-}[`++quorum(timepoint)++`] * {xref-GovernorVotesQuorumFraction-updateQuorumNumerator-uint256-}[`++updateQuorumNumerator(newQuorumNumerator)++`] * {xref-GovernorVotesQuorumFraction-_updateQuorumNumerator-uint256-}[`++_updateQuorumNumerator(newQuorumNumerator)++`] +* {xref-GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-}[`++_optimisticUpperLookupRecent(ckpts, timepoint)++`] [.contract-subindex-inherited] .GovernorVotes @@ -3461,6 +4410,7 @@ fraction of the total supply. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -3499,6 +4449,7 @@ fraction of the total supply. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] * {xref-Governor-votingPeriod--}[`++votingPeriod()++`] * {xref-Governor-BALLOT_TYPEHASH-bytes32}[`++BALLOT_TYPEHASH()++`] @@ -3612,7 +4563,6 @@ fraction of the total supply. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -3625,6 +4575,7 @@ fraction of the total supply. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -3706,6 +4657,12 @@ Requirements: - New numerator must be smaller or equal to the denominator. +[.contract-item] +[[GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-]] +==== `[.contract-item-name]#++_optimisticUpperLookupRecent++#++(struct Checkpoints.Trace208 ckpts, uint256 timepoint) → uint256++` [.item-kind]#internal# + +Returns the numerator at a specific timepoint. + [.contract-item] [[GovernorVotesQuorumFraction-QuorumNumeratorUpdated-uint256-uint256-]] ==== `[.contract-item-name]#++QuorumNumeratorUpdated++#++(uint256 oldQuorumNumerator, uint256 newQuorumNumerator)++` [.item-kind]#event# @@ -3716,6 +4673,381 @@ Requirements: The quorum set is not a valid fraction. +:SuperQuorumNumeratorUpdated: pass:normal[xref:#GovernorVotesSuperQuorumFraction-SuperQuorumNumeratorUpdated-uint256-uint256-[`++SuperQuorumNumeratorUpdated++`]] +:GovernorInvalidSuperQuorumFraction: pass:normal[xref:#GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumFraction-uint256-uint256-[`++GovernorInvalidSuperQuorumFraction++`]] +:GovernorInvalidSuperQuorumTooSmall: pass:normal[xref:#GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumTooSmall-uint256-uint256-[`++GovernorInvalidSuperQuorumTooSmall++`]] +:GovernorInvalidQuorumTooLarge: pass:normal[xref:#GovernorVotesSuperQuorumFraction-GovernorInvalidQuorumTooLarge-uint256-uint256-[`++GovernorInvalidQuorumTooLarge++`]] +:constructor: pass:normal[xref:#GovernorVotesSuperQuorumFraction-constructor-uint256-[`++constructor++`]] +:superQuorumNumerator: pass:normal[xref:#GovernorVotesSuperQuorumFraction-superQuorumNumerator--[`++superQuorumNumerator++`]] +:superQuorumNumerator: pass:normal[xref:#GovernorVotesSuperQuorumFraction-superQuorumNumerator-uint256-[`++superQuorumNumerator++`]] +:superQuorum: pass:normal[xref:#GovernorVotesSuperQuorumFraction-superQuorum-uint256-[`++superQuorum++`]] +:updateSuperQuorumNumerator: pass:normal[xref:#GovernorVotesSuperQuorumFraction-updateSuperQuorumNumerator-uint256-[`++updateSuperQuorumNumerator++`]] +:_updateSuperQuorumNumerator: pass:normal[xref:#GovernorVotesSuperQuorumFraction-_updateSuperQuorumNumerator-uint256-[`++_updateSuperQuorumNumerator++`]] +:_updateQuorumNumerator: pass:normal[xref:#GovernorVotesSuperQuorumFraction-_updateQuorumNumerator-uint256-[`++_updateQuorumNumerator++`]] +:state: pass:normal[xref:#GovernorVotesSuperQuorumFraction-state-uint256-[`++state++`]] + +:constructor-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-constructor-uint256-[`++constructor++`]] +:superQuorumNumerator-: pass:normal[xref:#GovernorVotesSuperQuorumFraction-superQuorumNumerator--[`++superQuorumNumerator++`]] +:superQuorumNumerator-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-superQuorumNumerator-uint256-[`++superQuorumNumerator++`]] +:superQuorum-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-superQuorum-uint256-[`++superQuorum++`]] +:updateSuperQuorumNumerator-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-updateSuperQuorumNumerator-uint256-[`++updateSuperQuorumNumerator++`]] +:_updateSuperQuorumNumerator-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-_updateSuperQuorumNumerator-uint256-[`++_updateSuperQuorumNumerator++`]] +:_updateQuorumNumerator-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-_updateQuorumNumerator-uint256-[`++_updateQuorumNumerator++`]] +:state-uint256: pass:normal[xref:#GovernorVotesSuperQuorumFraction-state-uint256-[`++state++`]] + +[.contract] +[[GovernorVotesSuperQuorumFraction]] +=== `++GovernorVotesSuperQuorumFraction++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol"; +``` + +Extension of {GovernorVotesQuorumFraction} with a super quorum expressed as a +fraction of the total supply. Proposals that meet the super quorum (and have a majority of for votes) advance to +the `Succeeded` state before the proposal deadline. + +[.contract-index] +.Functions +-- +* {xref-GovernorVotesSuperQuorumFraction-constructor-uint256-}[`++constructor(superQuorumNumeratorValue)++`] +* {xref-GovernorVotesSuperQuorumFraction-superQuorumNumerator--}[`++superQuorumNumerator()++`] +* {xref-GovernorVotesSuperQuorumFraction-superQuorumNumerator-uint256-}[`++superQuorumNumerator(timepoint)++`] +* {xref-GovernorVotesSuperQuorumFraction-superQuorum-uint256-}[`++superQuorum(timepoint)++`] +* {xref-GovernorVotesSuperQuorumFraction-updateSuperQuorumNumerator-uint256-}[`++updateSuperQuorumNumerator(newSuperQuorumNumerator)++`] +* {xref-GovernorVotesSuperQuorumFraction-_updateSuperQuorumNumerator-uint256-}[`++_updateSuperQuorumNumerator(newSuperQuorumNumerator)++`] +* {xref-GovernorVotesSuperQuorumFraction-_updateQuorumNumerator-uint256-}[`++_updateQuorumNumerator(newQuorumNumerator)++`] +* {xref-GovernorVotesSuperQuorumFraction-state-uint256-}[`++state(proposalId)++`] + +[.contract-subindex-inherited] +.GovernorSuperQuorum +* {xref-GovernorSuperQuorum-proposalVotes-uint256-}[`++proposalVotes(proposalId)++`] + +[.contract-subindex-inherited] +.GovernorVotesQuorumFraction +* {xref-GovernorVotesQuorumFraction-quorumNumerator--}[`++quorumNumerator()++`] +* {xref-GovernorVotesQuorumFraction-quorumNumerator-uint256-}[`++quorumNumerator(timepoint)++`] +* {xref-GovernorVotesQuorumFraction-quorumDenominator--}[`++quorumDenominator()++`] +* {xref-GovernorVotesQuorumFraction-quorum-uint256-}[`++quorum(timepoint)++`] +* {xref-GovernorVotesQuorumFraction-updateQuorumNumerator-uint256-}[`++updateQuorumNumerator(newQuorumNumerator)++`] +* {xref-GovernorVotesQuorumFraction-_optimisticUpperLookupRecent-struct-Checkpoints-Trace208-uint256-}[`++_optimisticUpperLookupRecent(ckpts, timepoint)++`] + +[.contract-subindex-inherited] +.GovernorVotes +* {xref-GovernorVotes-token--}[`++token()++`] +* {xref-GovernorVotes-clock--}[`++clock()++`] +* {xref-GovernorVotes-CLOCK_MODE--}[`++CLOCK_MODE()++`] +* {xref-GovernorVotes-_getVotes-address-uint256-bytes-}[`++_getVotes(account, timepoint, )++`] + +[.contract-subindex-inherited] +.Governor +* {xref-Governor-receive--}[`++receive()++`] +* {xref-Governor-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-Governor-name--}[`++name()++`] +* {xref-Governor-version--}[`++version()++`] +* {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] +* {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] +* {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] +* {xref-Governor-proposalProposer-uint256-}[`++proposalProposer(proposalId)++`] +* {xref-Governor-proposalEta-uint256-}[`++proposalEta(proposalId)++`] +* {xref-Governor-proposalNeedsQueuing-uint256-}[`++proposalNeedsQueuing()++`] +* {xref-Governor-_checkGovernance--}[`++_checkGovernance()++`] +* {xref-Governor-_quorumReached-uint256-}[`++_quorumReached(proposalId)++`] +* {xref-Governor-_voteSucceeded-uint256-}[`++_voteSucceeded(proposalId)++`] +* {xref-Governor-_countVote-uint256-address-uint8-uint256-bytes-}[`++_countVote(proposalId, account, support, totalWeight, params)++`] +* {xref-Governor-_tallyUpdated-uint256-}[`++_tallyUpdated(proposalId)++`] +* {xref-Governor-_defaultParams--}[`++_defaultParams()++`] +* {xref-Governor-propose-address---uint256---bytes---string-}[`++propose(targets, values, calldatas, description)++`] +* {xref-Governor-_propose-address---uint256---bytes---string-address-}[`++_propose(targets, values, calldatas, description, proposer)++`] +* {xref-Governor-queue-address---uint256---bytes---bytes32-}[`++queue(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-}[`++_queueOperations(, , , , )++`] +* {xref-Governor-execute-address---uint256---bytes---bytes32-}[`++execute(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-}[`++_executeOperations(, targets, values, calldatas, )++`] +* {xref-Governor-cancel-address---uint256---bytes---bytes32-}[`++cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_cancel-address---uint256---bytes---bytes32-}[`++_cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getVotes-address-uint256-}[`++getVotes(account, timepoint)++`] +* {xref-Governor-getVotesWithParams-address-uint256-bytes-}[`++getVotesWithParams(account, timepoint, params)++`] +* {xref-Governor-castVote-uint256-uint8-}[`++castVote(proposalId, support)++`] +* {xref-Governor-castVoteWithReason-uint256-uint8-string-}[`++castVoteWithReason(proposalId, support, reason)++`] +* {xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-}[`++castVoteWithReasonAndParams(proposalId, support, reason, params)++`] +* {xref-Governor-castVoteBySig-uint256-uint8-address-bytes-}[`++castVoteBySig(proposalId, support, voter, signature)++`] +* {xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-}[`++castVoteWithReasonAndParamsBySig(proposalId, support, voter, reason, params, signature)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-}[`++_castVote(proposalId, account, support, reason)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-bytes-}[`++_castVote(proposalId, account, support, reason, params)++`] +* {xref-Governor-relay-address-uint256-bytes-}[`++relay(target, value, data)++`] +* {xref-Governor-_executor--}[`++_executor()++`] +* {xref-Governor-onERC721Received-address-address-uint256-bytes-}[`++onERC721Received(, , , )++`] +* {xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-}[`++onERC1155Received(, , , , )++`] +* {xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-}[`++onERC1155BatchReceived(, , , , )++`] +* {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] +* {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] +* {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] +* {xref-Governor-votingDelay--}[`++votingDelay()++`] +* {xref-Governor-votingPeriod--}[`++votingPeriod()++`] +* {xref-Governor-BALLOT_TYPEHASH-bytes32}[`++BALLOT_TYPEHASH()++`] +* {xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32}[`++EXTENDED_BALLOT_TYPEHASH()++`] + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-COUNTING_MODE--}[`++COUNTING_MODE()++`] +* {xref-IGovernor-hasVoted-uint256-address-}[`++hasVoted(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-nonces-address-}[`++nonces(owner)++`] +* {xref-Nonces-_useNonce-address-}[`++_useNonce(owner)++`] +* {xref-Nonces-_useCheckedNonce-address-uint256-}[`++_useCheckedNonce(owner, nonce)++`] + +[.contract-subindex-inherited] +.EIP712 +* {xref-EIP712-_domainSeparatorV4--}[`++_domainSeparatorV4()++`] +* {xref-EIP712-_hashTypedDataV4-bytes32-}[`++_hashTypedDataV4(structHash)++`] +* {xref-EIP712-eip712Domain--}[`++eip712Domain()++`] +* {xref-EIP712-_EIP712Name--}[`++_EIP712Name()++`] +* {xref-EIP712-_EIP712Version--}[`++_EIP712Version()++`] + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- +* {xref-GovernorVotesSuperQuorumFraction-SuperQuorumNumeratorUpdated-uint256-uint256-}[`++SuperQuorumNumeratorUpdated(oldSuperQuorumNumerator, newSuperQuorumNumerator)++`] + +[.contract-subindex-inherited] +.GovernorSuperQuorum + +[.contract-subindex-inherited] +.GovernorVotesQuorumFraction +* {xref-GovernorVotesQuorumFraction-QuorumNumeratorUpdated-uint256-uint256-}[`++QuorumNumeratorUpdated(oldQuorumNumerator, newQuorumNumerator)++`] + +[.contract-subindex-inherited] +.GovernorVotes + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-}[`++ProposalCreated(proposalId, proposer, targets, values, signatures, calldatas, voteStart, voteEnd, description)++`] +* {xref-IGovernor-ProposalQueued-uint256-uint256-}[`++ProposalQueued(proposalId, etaSeconds)++`] +* {xref-IGovernor-ProposalExecuted-uint256-}[`++ProposalExecuted(proposalId)++`] +* {xref-IGovernor-ProposalCanceled-uint256-}[`++ProposalCanceled(proposalId)++`] +* {xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-}[`++VoteCast(voter, proposalId, support, weight, reason)++`] +* {xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-}[`++VoteCastWithParams(voter, proposalId, support, weight, reason, params)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 +* {xref-IERC5267-EIP712DomainChanged--}[`++EIP712DomainChanged()++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- +* {xref-GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumFraction-uint256-uint256-}[`++GovernorInvalidSuperQuorumFraction(superQuorumNumerator, denominator)++`] +* {xref-GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumTooSmall-uint256-uint256-}[`++GovernorInvalidSuperQuorumTooSmall(superQuorumNumerator, quorumNumerator)++`] +* {xref-GovernorVotesSuperQuorumFraction-GovernorInvalidQuorumTooLarge-uint256-uint256-}[`++GovernorInvalidQuorumTooLarge(quorumNumerator, superQuorumNumerator)++`] + +[.contract-subindex-inherited] +.GovernorSuperQuorum + +[.contract-subindex-inherited] +.GovernorVotesQuorumFraction +* {xref-GovernorVotesQuorumFraction-GovernorInvalidQuorumFraction-uint256-uint256-}[`++GovernorInvalidQuorumFraction(quorumNumerator, quorumDenominator)++`] + +[.contract-subindex-inherited] +.GovernorVotes + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] +* {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] +* {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] +* {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] +* {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] +* {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] +* {xref-IGovernor-GovernorInvalidVotingPeriod-uint256-}[`++GovernorInvalidVotingPeriod(votingPeriod)++`] +* {xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-}[`++GovernorInsufficientProposerVotes(proposer, votes, threshold)++`] +* {xref-IGovernor-GovernorRestrictedProposer-address-}[`++GovernorRestrictedProposer(proposer)++`] +* {xref-IGovernor-GovernorInvalidVoteType--}[`++GovernorInvalidVoteType()++`] +* {xref-IGovernor-GovernorInvalidVoteParams--}[`++GovernorInvalidVoteParams()++`] +* {xref-IGovernor-GovernorQueueNotImplemented--}[`++GovernorQueueNotImplemented()++`] +* {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-InvalidAccountNonce-address-uint256-}[`++InvalidAccountNonce(account, currentNonce)++`] + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-constructor-uint256-]] +==== `[.contract-item-name]#++constructor++#++(uint256 superQuorumNumeratorValue)++` [.item-kind]#internal# + +Initialize super quorum as a fraction of the token's total supply. + +The super quorum is specified as a fraction of the token's total supply and has to +be greater than the quorum. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-superQuorumNumerator--]] +==== `[.contract-item-name]#++superQuorumNumerator++#++() → uint256++` [.item-kind]#public# + +Returns the current super quorum numerator. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-superQuorumNumerator-uint256-]] +==== `[.contract-item-name]#++superQuorumNumerator++#++(uint256 timepoint) → uint256++` [.item-kind]#public# + +Returns the super quorum numerator at a specific `timepoint`. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-superQuorum-uint256-]] +==== `[.contract-item-name]#++superQuorum++#++(uint256 timepoint) → uint256++` [.item-kind]#public# + +Returns the super quorum for a `timepoint`, in terms of number of votes: `supply * numerator / denominator`. +See {GovernorSuperQuorum-superQuorum} for more details. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-updateSuperQuorumNumerator-uint256-]] +==== `[.contract-item-name]#++updateSuperQuorumNumerator++#++(uint256 newSuperQuorumNumerator)++` [.item-kind]#public# + +Changes the super quorum numerator. + +Emits a {SuperQuorumNumeratorUpdated} event. + +Requirements: + +- Must be called through a governance proposal. +- New super quorum numerator must be smaller or equal to the denominator. +- New super quorum numerator must be greater than or equal to the quorum numerator. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-_updateSuperQuorumNumerator-uint256-]] +==== `[.contract-item-name]#++_updateSuperQuorumNumerator++#++(uint256 newSuperQuorumNumerator)++` [.item-kind]#internal# + +Changes the super quorum numerator. + +Emits a {SuperQuorumNumeratorUpdated} event. + +Requirements: + +- New super quorum numerator must be smaller or equal to the denominator. +- New super quorum numerator must be greater than or equal to the quorum numerator. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-_updateQuorumNumerator-uint256-]] +==== `[.contract-item-name]#++_updateQuorumNumerator++#++(uint256 newQuorumNumerator)++` [.item-kind]#internal# + +Overrides {GovernorVotesQuorumFraction-_updateQuorumNumerator} to ensure the super +quorum numerator is greater than or equal to the quorum numerator. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-state-uint256-]] +==== `[.contract-item-name]#++state++#++(uint256 proposalId) → enum IGovernor.ProposalState++` [.item-kind]#public# + +Overridden version of the {Governor-state} function that checks if the proposal has reached the super +quorum. + +NOTE: If the proposal reaches super quorum but {_voteSucceeded} returns false, eg, assuming the super quorum +has been set low enough that both FOR and AGAINST votes have exceeded it and AGAINST votes exceed FOR votes, +the proposal continues to be active until {_voteSucceeded} returns true or the proposal deadline is reached. +This means that with a low super quorum it is also possible that a vote can succeed prematurely before enough +AGAINST voters have a chance to vote. Hence, it is recommended to set a high enough super quorum to avoid these +types of scenarios. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-SuperQuorumNumeratorUpdated-uint256-uint256-]] +==== `[.contract-item-name]#++SuperQuorumNumeratorUpdated++#++(uint256 oldSuperQuorumNumerator, uint256 newSuperQuorumNumerator)++` [.item-kind]#event# + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumFraction-uint256-uint256-]] +==== `[.contract-item-name]#++GovernorInvalidSuperQuorumFraction++#++(uint256 superQuorumNumerator, uint256 denominator)++` [.item-kind]#error# + +The super quorum set is not valid as it exceeds the quorum denominator. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-GovernorInvalidSuperQuorumTooSmall-uint256-uint256-]] +==== `[.contract-item-name]#++GovernorInvalidSuperQuorumTooSmall++#++(uint256 superQuorumNumerator, uint256 quorumNumerator)++` [.item-kind]#error# + +The super quorum set is not valid as it is smaller or equal to the quorum. + +[.contract-item] +[[GovernorVotesSuperQuorumFraction-GovernorInvalidQuorumTooLarge-uint256-uint256-]] +==== `[.contract-item-name]#++GovernorInvalidQuorumTooLarge++#++(uint256 quorumNumerator, uint256 superQuorumNumerator)++` [.item-kind]#error# + +The quorum set is not valid as it exceeds the super quorum. + === Extensions :ExecutionPlan: pass:normal[xref:#GovernorTimelockAccess-ExecutionPlan[`++ExecutionPlan++`]] @@ -3739,9 +5071,24 @@ The quorum set is not a valid fraction. :_executeOperations: pass:normal[xref:#GovernorTimelockAccess-_executeOperations-uint256-address---uint256---bytes---bytes32-[`++_executeOperations++`]] :_cancel: pass:normal[xref:#GovernorTimelockAccess-_cancel-address---uint256---bytes---bytes32-[`++_cancel++`]] +:constructor-address-uint32: pass:normal[xref:#GovernorTimelockAccess-constructor-address-uint32-[`++constructor++`]] +:accessManager-: pass:normal[xref:#GovernorTimelockAccess-accessManager--[`++accessManager++`]] +:baseDelaySeconds-: pass:normal[xref:#GovernorTimelockAccess-baseDelaySeconds--[`++baseDelaySeconds++`]] +:setBaseDelaySeconds-uint32: pass:normal[xref:#GovernorTimelockAccess-setBaseDelaySeconds-uint32-[`++setBaseDelaySeconds++`]] +:_setBaseDelaySeconds-uint32: pass:normal[xref:#GovernorTimelockAccess-_setBaseDelaySeconds-uint32-[`++_setBaseDelaySeconds++`]] +:isAccessManagerIgnored-address-bytes4: pass:normal[xref:#GovernorTimelockAccess-isAccessManagerIgnored-address-bytes4-[`++isAccessManagerIgnored++`]] +:setAccessManagerIgnored-address-bytes4---bool: pass:normal[xref:#GovernorTimelockAccess-setAccessManagerIgnored-address-bytes4---bool-[`++setAccessManagerIgnored++`]] +:_setAccessManagerIgnored-address-bytes4-bool: pass:normal[xref:#GovernorTimelockAccess-_setAccessManagerIgnored-address-bytes4-bool-[`++_setAccessManagerIgnored++`]] +:proposalExecutionPlan-uint256: pass:normal[xref:#GovernorTimelockAccess-proposalExecutionPlan-uint256-[`++proposalExecutionPlan++`]] +:proposalNeedsQueuing-uint256: pass:normal[xref:#GovernorTimelockAccess-proposalNeedsQueuing-uint256-[`++proposalNeedsQueuing++`]] +:propose-address---uint256---bytes---string: pass:normal[xref:#GovernorTimelockAccess-propose-address---uint256---bytes---string-[`++propose++`]] +:_queueOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockAccess-_queueOperations-uint256-address---uint256---bytes---bytes32-[`++_queueOperations++`]] +:_executeOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockAccess-_executeOperations-uint256-address---uint256---bytes---bytes32-[`++_executeOperations++`]] +:_cancel-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockAccess-_cancel-address---uint256---bytes---bytes32-[`++_cancel++`]] + [.contract] [[GovernorTimelockAccess]] -=== `++GovernorTimelockAccess++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorTimelockAccess.sol[{github-icon},role=heading-link] +=== `++GovernorTimelockAccess++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorTimelockAccess.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3800,6 +5147,7 @@ the same time. See {AccessManager-schedule} for a workaround. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -3834,6 +5182,7 @@ the same time. See {AccessManager-schedule} for a workaround. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -3947,7 +5296,6 @@ the same time. See {AccessManager-schedule} for a workaround. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -3960,6 +5308,7 @@ the same time. See {AccessManager-schedule} for a workaround. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -4078,7 +5427,7 @@ Mechanism to execute a proposal, potentially going through {AccessManager-execut [[GovernorTimelockAccess-_cancel-address---uint256---bytes---bytes32-]] ==== `[.contract-item-name]#++_cancel++#++(address[] targets, uint256[] values, bytes[] calldatas, bytes32 descriptionHash) → uint256++` [.item-kind]#internal# -See {IGovernor-_cancel} +See {Governor-_cancel} [.contract-item] [[GovernorTimelockAccess-BaseDelaySet-uint32-uint32-]] @@ -4111,9 +5460,19 @@ See {IGovernor-_cancel} :_executor: pass:normal[xref:#GovernorTimelockControl-_executor--[`++_executor++`]] :updateTimelock: pass:normal[xref:#GovernorTimelockControl-updateTimelock-contract-TimelockController-[`++updateTimelock++`]] +:constructor-contract-TimelockController: pass:normal[xref:#GovernorTimelockControl-constructor-contract-TimelockController-[`++constructor++`]] +:state-uint256: pass:normal[xref:#GovernorTimelockControl-state-uint256-[`++state++`]] +:timelock-: pass:normal[xref:#GovernorTimelockControl-timelock--[`++timelock++`]] +:proposalNeedsQueuing-uint256: pass:normal[xref:#GovernorTimelockControl-proposalNeedsQueuing-uint256-[`++proposalNeedsQueuing++`]] +:_queueOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockControl-_queueOperations-uint256-address---uint256---bytes---bytes32-[`++_queueOperations++`]] +:_executeOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockControl-_executeOperations-uint256-address---uint256---bytes---bytes32-[`++_executeOperations++`]] +:_cancel-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockControl-_cancel-address---uint256---bytes---bytes32-[`++_cancel++`]] +:_executor-: pass:normal[xref:#GovernorTimelockControl-_executor--[`++_executor++`]] +:updateTimelock-contract-TimelockController: pass:normal[xref:#GovernorTimelockControl-updateTimelock-contract-TimelockController-[`++updateTimelock++`]] + [.contract] [[GovernorTimelockControl]] -=== `++GovernorTimelockControl++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorTimelockControl.sol[{github-icon},role=heading-link] +=== `++GovernorTimelockControl++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorTimelockControl.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -4128,7 +5487,7 @@ Using this model means the proposal will be operated by the {TimelockController} the assets and permissions must be attached to the {TimelockController}. Any asset sent to the {Governor} will be inaccessible from a proposal, unless executed via {Governor-relay}. -WARNING: Setting up the TimelockController to have additional proposers or cancellers besides the governor is very +WARNING: Setting up the TimelockController to have additional proposers or cancelers besides the governor is very risky, as it grants them the ability to: 1) execute operations as the timelock, and thus possibly performing operations or accessing funds that are expected to only be accessible through a vote, and 2) block governance proposals that have been approved by the voters, effectively executing a Denial of Service attack. @@ -4153,6 +5512,7 @@ proposals that have been approved by the voters, effectively executing a Denial * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] * {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] @@ -4186,6 +5546,7 @@ proposals that have been approved by the voters, effectively executing a Denial * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -4295,7 +5656,6 @@ proposals that have been approved by the voters, effectively executing a Denial * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -4308,6 +5668,7 @@ proposals that have been approved by the voters, effectively executing a Denial * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -4407,9 +5768,20 @@ Emitted when the timelock controller used for proposal execution is modified. :__acceptAdmin: pass:normal[xref:#GovernorTimelockCompound-__acceptAdmin--[`++__acceptAdmin++`]] :updateTimelock: pass:normal[xref:#GovernorTimelockCompound-updateTimelock-contract-ICompoundTimelock-[`++updateTimelock++`]] +:constructor-contract-ICompoundTimelock: pass:normal[xref:#GovernorTimelockCompound-constructor-contract-ICompoundTimelock-[`++constructor++`]] +:state-uint256: pass:normal[xref:#GovernorTimelockCompound-state-uint256-[`++state++`]] +:timelock-: pass:normal[xref:#GovernorTimelockCompound-timelock--[`++timelock++`]] +:proposalNeedsQueuing-uint256: pass:normal[xref:#GovernorTimelockCompound-proposalNeedsQueuing-uint256-[`++proposalNeedsQueuing++`]] +:_queueOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockCompound-_queueOperations-uint256-address---uint256---bytes---bytes32-[`++_queueOperations++`]] +:_executeOperations-uint256-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockCompound-_executeOperations-uint256-address---uint256---bytes---bytes32-[`++_executeOperations++`]] +:_cancel-address---uint256---bytes---bytes32: pass:normal[xref:#GovernorTimelockCompound-_cancel-address---uint256---bytes---bytes32-[`++_cancel++`]] +:_executor-: pass:normal[xref:#GovernorTimelockCompound-_executor--[`++_executor++`]] +:__acceptAdmin-: pass:normal[xref:#GovernorTimelockCompound-__acceptAdmin--[`++__acceptAdmin++`]] +:updateTimelock-contract-ICompoundTimelock: pass:normal[xref:#GovernorTimelockCompound-updateTimelock-contract-ICompoundTimelock-[`++updateTimelock++`]] + [.contract] [[GovernorTimelockCompound]] -=== `++GovernorTimelockCompound++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorTimelockCompound.sol[{github-icon},role=heading-link] +=== `++GovernorTimelockCompound++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorTimelockCompound.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -4417,7 +5789,7 @@ import "@openzeppelin/contracts/governance/extensions/GovernorTimelockCompound.s ``` Extension of {Governor} that binds the execution process to a Compound Timelock. This adds a delay, enforced by -the external timelock to all successful proposal (in addition to the voting duration). The {Governor} needs to be +the external timelock to all successful proposals (in addition to the voting duration). The {Governor} needs to be the admin of the timelock for any operation to be performed. A public, unrestricted, {GovernorTimelockCompound-__acceptAdmin} is available to accept ownership of the timelock. @@ -4446,6 +5818,7 @@ inaccessible from a proposal, unless executed via {Governor-relay}. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] * {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] @@ -4479,6 +5852,7 @@ inaccessible from a proposal, unless executed via {Governor-relay}. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -4588,7 +5962,6 @@ inaccessible from a proposal, unless executed via {Governor-relay}. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -4601,6 +5974,7 @@ inaccessible from a proposal, unless executed via {Governor-relay}. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -4715,9 +6089,20 @@ Emitted when the timelock controller used for proposal execution is modified. :_setVotingPeriod: pass:normal[xref:#GovernorSettings-_setVotingPeriod-uint32-[`++_setVotingPeriod++`]] :_setProposalThreshold: pass:normal[xref:#GovernorSettings-_setProposalThreshold-uint256-[`++_setProposalThreshold++`]] +:constructor-uint48-uint32-uint256: pass:normal[xref:#GovernorSettings-constructor-uint48-uint32-uint256-[`++constructor++`]] +:votingDelay-: pass:normal[xref:#GovernorSettings-votingDelay--[`++votingDelay++`]] +:votingPeriod-: pass:normal[xref:#GovernorSettings-votingPeriod--[`++votingPeriod++`]] +:proposalThreshold-: pass:normal[xref:#GovernorSettings-proposalThreshold--[`++proposalThreshold++`]] +:setVotingDelay-uint48: pass:normal[xref:#GovernorSettings-setVotingDelay-uint48-[`++setVotingDelay++`]] +:setVotingPeriod-uint32: pass:normal[xref:#GovernorSettings-setVotingPeriod-uint32-[`++setVotingPeriod++`]] +:setProposalThreshold-uint256: pass:normal[xref:#GovernorSettings-setProposalThreshold-uint256-[`++setProposalThreshold++`]] +:_setVotingDelay-uint48: pass:normal[xref:#GovernorSettings-_setVotingDelay-uint48-[`++_setVotingDelay++`]] +:_setVotingPeriod-uint32: pass:normal[xref:#GovernorSettings-_setVotingPeriod-uint32-[`++_setVotingPeriod++`]] +:_setProposalThreshold-uint256: pass:normal[xref:#GovernorSettings-_setProposalThreshold-uint256-[`++_setProposalThreshold++`]] + [.contract] [[GovernorSettings]] -=== `++GovernorSettings++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorSettings.sol[{github-icon},role=heading-link] +=== `++GovernorSettings++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorSettings.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -4747,6 +6132,7 @@ Extension of {Governor} for settings updatable through governance. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] * {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] @@ -4785,6 +6171,7 @@ Extension of {Governor} for settings updatable through governance. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-quorum-uint256-}[`++quorum(timepoint)++`] @@ -4894,7 +6281,6 @@ Extension of {Governor} for settings updatable through governance. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -4907,6 +6293,7 @@ Extension of {Governor} for settings updatable through governance. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -5022,9 +6409,16 @@ Emits a {ProposalThresholdSet} event. :setLateQuorumVoteExtension: pass:normal[xref:#GovernorPreventLateQuorum-setLateQuorumVoteExtension-uint48-[`++setLateQuorumVoteExtension++`]] :_setLateQuorumVoteExtension: pass:normal[xref:#GovernorPreventLateQuorum-_setLateQuorumVoteExtension-uint48-[`++_setLateQuorumVoteExtension++`]] +:constructor-uint48: pass:normal[xref:#GovernorPreventLateQuorum-constructor-uint48-[`++constructor++`]] +:proposalDeadline-uint256: pass:normal[xref:#GovernorPreventLateQuorum-proposalDeadline-uint256-[`++proposalDeadline++`]] +:_tallyUpdated-uint256: pass:normal[xref:#GovernorPreventLateQuorum-_tallyUpdated-uint256-[`++_tallyUpdated++`]] +:lateQuorumVoteExtension-: pass:normal[xref:#GovernorPreventLateQuorum-lateQuorumVoteExtension--[`++lateQuorumVoteExtension++`]] +:setLateQuorumVoteExtension-uint48: pass:normal[xref:#GovernorPreventLateQuorum-setLateQuorumVoteExtension-uint48-[`++setLateQuorumVoteExtension++`]] +:_setLateQuorumVoteExtension-uint48: pass:normal[xref:#GovernorPreventLateQuorum-_setLateQuorumVoteExtension-uint48-[`++_setLateQuorumVoteExtension++`]] + [.contract] [[GovernorPreventLateQuorum]] -=== `++GovernorPreventLateQuorum++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorPreventLateQuorum.sol[{github-icon},role=heading-link] +=== `++GovernorPreventLateQuorum++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorPreventLateQuorum.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5056,6 +6450,7 @@ proposal. * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -5093,6 +6488,7 @@ proposal. * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -5203,7 +6599,6 @@ proposal. * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -5216,6 +6611,7 @@ proposal. * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -5307,9 +6703,17 @@ Emitted when the {lateQuorumVoteExtension} parameter is changed. :proposalDetails: pass:normal[xref:#GovernorStorage-proposalDetails-uint256-[`++proposalDetails++`]] :proposalDetailsAt: pass:normal[xref:#GovernorStorage-proposalDetailsAt-uint256-[`++proposalDetailsAt++`]] +:_propose-address---uint256---bytes---string-address: pass:normal[xref:#GovernorStorage-_propose-address---uint256---bytes---string-address-[`++_propose++`]] +:queue-uint256: pass:normal[xref:#GovernorStorage-queue-uint256-[`++queue++`]] +:execute-uint256: pass:normal[xref:#GovernorStorage-execute-uint256-[`++execute++`]] +:cancel-uint256: pass:normal[xref:#GovernorStorage-cancel-uint256-[`++cancel++`]] +:proposalCount-: pass:normal[xref:#GovernorStorage-proposalCount--[`++proposalCount++`]] +:proposalDetails-uint256: pass:normal[xref:#GovernorStorage-proposalDetails-uint256-[`++proposalDetails++`]] +:proposalDetailsAt-uint256: pass:normal[xref:#GovernorStorage-proposalDetailsAt-uint256-[`++proposalDetailsAt++`]] + [.contract] [[GovernorStorage]] -=== `++GovernorStorage++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/extensions/GovernorStorage.sol[{github-icon},role=heading-link] +=== `++GovernorStorage++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorStorage.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5342,6 +6746,7 @@ Use cases for this module include: * {xref-Governor-name--}[`++name()++`] * {xref-Governor-version--}[`++version()++`] * {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] * {xref-Governor-state-uint256-}[`++state(proposalId)++`] * {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] * {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] @@ -5380,6 +6785,7 @@ Use cases for this module include: * {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] * {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] * {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] * {xref-Governor-clock--}[`++clock()++`] * {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] * {xref-Governor-votingDelay--}[`++votingDelay()++`] @@ -5488,7 +6894,6 @@ Use cases for this module include: * {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] * {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] * {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] -* {xref-IGovernor-GovernorOnlyProposer-address-}[`++GovernorOnlyProposer(account)++`] * {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] * {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] * {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] @@ -5501,6 +6906,7 @@ Use cases for this module include: * {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] * {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] [.contract-subindex-inherited] .IERC6372 @@ -5533,7 +6939,7 @@ Hook into the proposing mechanism [[GovernorStorage-queue-uint256-]] ==== `[.contract-item-name]#++queue++#++(uint256 proposalId)++` [.item-kind]#public# -Version of {IGovernorTimelock-queue} with only `proposalId` as an argument. +Version of {IGovernor-queue} with only `proposalId` as an argument. [.contract-item] [[GovernorStorage-execute-uint256-]] @@ -5565,6 +6971,518 @@ Returns the details of a proposalId. Reverts if `proposalId` is not a known prop Returns the details (including the proposalId) of a proposal given its sequential index. +:ProposalGuardianSet: pass:normal[xref:#GovernorProposalGuardian-ProposalGuardianSet-address-address-[`++ProposalGuardianSet++`]] +:proposalGuardian: pass:normal[xref:#GovernorProposalGuardian-proposalGuardian--[`++proposalGuardian++`]] +:setProposalGuardian: pass:normal[xref:#GovernorProposalGuardian-setProposalGuardian-address-[`++setProposalGuardian++`]] +:_setProposalGuardian: pass:normal[xref:#GovernorProposalGuardian-_setProposalGuardian-address-[`++_setProposalGuardian++`]] +:_validateCancel: pass:normal[xref:#GovernorProposalGuardian-_validateCancel-uint256-address-[`++_validateCancel++`]] + +:proposalGuardian-: pass:normal[xref:#GovernorProposalGuardian-proposalGuardian--[`++proposalGuardian++`]] +:setProposalGuardian-address: pass:normal[xref:#GovernorProposalGuardian-setProposalGuardian-address-[`++setProposalGuardian++`]] +:_setProposalGuardian-address: pass:normal[xref:#GovernorProposalGuardian-_setProposalGuardian-address-[`++_setProposalGuardian++`]] +:_validateCancel-uint256-address: pass:normal[xref:#GovernorProposalGuardian-_validateCancel-uint256-address-[`++_validateCancel++`]] + +[.contract] +[[GovernorProposalGuardian]] +=== `++GovernorProposalGuardian++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorProposalGuardian.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/governance/extensions/GovernorProposalGuardian.sol"; +``` + +Extension of {Governor} which adds a proposal guardian that can cancel proposals at any stage in the proposal's lifecycle. + +NOTE: if the proposal guardian is not configured, then proposers take this role for their proposals. + +[.contract-index] +.Functions +-- +* {xref-GovernorProposalGuardian-proposalGuardian--}[`++proposalGuardian()++`] +* {xref-GovernorProposalGuardian-setProposalGuardian-address-}[`++setProposalGuardian(newProposalGuardian)++`] +* {xref-GovernorProposalGuardian-_setProposalGuardian-address-}[`++_setProposalGuardian(newProposalGuardian)++`] +* {xref-GovernorProposalGuardian-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] + +[.contract-subindex-inherited] +.Governor +* {xref-Governor-receive--}[`++receive()++`] +* {xref-Governor-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-Governor-name--}[`++name()++`] +* {xref-Governor-version--}[`++version()++`] +* {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-state-uint256-}[`++state(proposalId)++`] +* {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] +* {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] +* {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] +* {xref-Governor-proposalProposer-uint256-}[`++proposalProposer(proposalId)++`] +* {xref-Governor-proposalEta-uint256-}[`++proposalEta(proposalId)++`] +* {xref-Governor-proposalNeedsQueuing-uint256-}[`++proposalNeedsQueuing()++`] +* {xref-Governor-_checkGovernance--}[`++_checkGovernance()++`] +* {xref-Governor-_quorumReached-uint256-}[`++_quorumReached(proposalId)++`] +* {xref-Governor-_voteSucceeded-uint256-}[`++_voteSucceeded(proposalId)++`] +* {xref-Governor-_getVotes-address-uint256-bytes-}[`++_getVotes(account, timepoint, params)++`] +* {xref-Governor-_countVote-uint256-address-uint8-uint256-bytes-}[`++_countVote(proposalId, account, support, totalWeight, params)++`] +* {xref-Governor-_tallyUpdated-uint256-}[`++_tallyUpdated(proposalId)++`] +* {xref-Governor-_defaultParams--}[`++_defaultParams()++`] +* {xref-Governor-propose-address---uint256---bytes---string-}[`++propose(targets, values, calldatas, description)++`] +* {xref-Governor-_propose-address---uint256---bytes---string-address-}[`++_propose(targets, values, calldatas, description, proposer)++`] +* {xref-Governor-queue-address---uint256---bytes---bytes32-}[`++queue(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-}[`++_queueOperations(, , , , )++`] +* {xref-Governor-execute-address---uint256---bytes---bytes32-}[`++execute(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-}[`++_executeOperations(, targets, values, calldatas, )++`] +* {xref-Governor-cancel-address---uint256---bytes---bytes32-}[`++cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_cancel-address---uint256---bytes---bytes32-}[`++_cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getVotes-address-uint256-}[`++getVotes(account, timepoint)++`] +* {xref-Governor-getVotesWithParams-address-uint256-bytes-}[`++getVotesWithParams(account, timepoint, params)++`] +* {xref-Governor-castVote-uint256-uint8-}[`++castVote(proposalId, support)++`] +* {xref-Governor-castVoteWithReason-uint256-uint8-string-}[`++castVoteWithReason(proposalId, support, reason)++`] +* {xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-}[`++castVoteWithReasonAndParams(proposalId, support, reason, params)++`] +* {xref-Governor-castVoteBySig-uint256-uint8-address-bytes-}[`++castVoteBySig(proposalId, support, voter, signature)++`] +* {xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-}[`++castVoteWithReasonAndParamsBySig(proposalId, support, voter, reason, params, signature)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-}[`++_castVote(proposalId, account, support, reason)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-bytes-}[`++_castVote(proposalId, account, support, reason, params)++`] +* {xref-Governor-relay-address-uint256-bytes-}[`++relay(target, value, data)++`] +* {xref-Governor-_executor--}[`++_executor()++`] +* {xref-Governor-onERC721Received-address-address-uint256-bytes-}[`++onERC721Received(, , , )++`] +* {xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-}[`++onERC1155Received(, , , , )++`] +* {xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-}[`++onERC1155BatchReceived(, , , , )++`] +* {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] +* {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] +* {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-clock--}[`++clock()++`] +* {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] +* {xref-Governor-votingDelay--}[`++votingDelay()++`] +* {xref-Governor-votingPeriod--}[`++votingPeriod()++`] +* {xref-Governor-quorum-uint256-}[`++quorum(timepoint)++`] +* {xref-Governor-BALLOT_TYPEHASH-bytes32}[`++BALLOT_TYPEHASH()++`] +* {xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32}[`++EXTENDED_BALLOT_TYPEHASH()++`] + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-COUNTING_MODE--}[`++COUNTING_MODE()++`] +* {xref-IGovernor-hasVoted-uint256-address-}[`++hasVoted(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-nonces-address-}[`++nonces(owner)++`] +* {xref-Nonces-_useNonce-address-}[`++_useNonce(owner)++`] +* {xref-Nonces-_useCheckedNonce-address-uint256-}[`++_useCheckedNonce(owner, nonce)++`] + +[.contract-subindex-inherited] +.EIP712 +* {xref-EIP712-_domainSeparatorV4--}[`++_domainSeparatorV4()++`] +* {xref-EIP712-_hashTypedDataV4-bytes32-}[`++_hashTypedDataV4(structHash)++`] +* {xref-EIP712-eip712Domain--}[`++eip712Domain()++`] +* {xref-EIP712-_EIP712Name--}[`++_EIP712Name()++`] +* {xref-EIP712-_EIP712Version--}[`++_EIP712Version()++`] + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- +* {xref-GovernorProposalGuardian-ProposalGuardianSet-address-address-}[`++ProposalGuardianSet(oldProposalGuardian, newProposalGuardian)++`] + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-}[`++ProposalCreated(proposalId, proposer, targets, values, signatures, calldatas, voteStart, voteEnd, description)++`] +* {xref-IGovernor-ProposalQueued-uint256-uint256-}[`++ProposalQueued(proposalId, etaSeconds)++`] +* {xref-IGovernor-ProposalExecuted-uint256-}[`++ProposalExecuted(proposalId)++`] +* {xref-IGovernor-ProposalCanceled-uint256-}[`++ProposalCanceled(proposalId)++`] +* {xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-}[`++VoteCast(voter, proposalId, support, weight, reason)++`] +* {xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-}[`++VoteCastWithParams(voter, proposalId, support, weight, reason, params)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 +* {xref-IERC5267-EIP712DomainChanged--}[`++EIP712DomainChanged()++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] +* {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] +* {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] +* {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] +* {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] +* {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] +* {xref-IGovernor-GovernorInvalidVotingPeriod-uint256-}[`++GovernorInvalidVotingPeriod(votingPeriod)++`] +* {xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-}[`++GovernorInsufficientProposerVotes(proposer, votes, threshold)++`] +* {xref-IGovernor-GovernorRestrictedProposer-address-}[`++GovernorRestrictedProposer(proposer)++`] +* {xref-IGovernor-GovernorInvalidVoteType--}[`++GovernorInvalidVoteType()++`] +* {xref-IGovernor-GovernorInvalidVoteParams--}[`++GovernorInvalidVoteParams()++`] +* {xref-IGovernor-GovernorQueueNotImplemented--}[`++GovernorQueueNotImplemented()++`] +* {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-InvalidAccountNonce-address-uint256-}[`++InvalidAccountNonce(account, currentNonce)++`] + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[GovernorProposalGuardian-proposalGuardian--]] +==== `[.contract-item-name]#++proposalGuardian++#++() → address++` [.item-kind]#public# + +Getter that returns the address of the proposal guardian. + +[.contract-item] +[[GovernorProposalGuardian-setProposalGuardian-address-]] +==== `[.contract-item-name]#++setProposalGuardian++#++(address newProposalGuardian)++` [.item-kind]#public# + +Update the proposal guardian's address. This operation can only be performed through a governance proposal. + +Emits a {ProposalGuardianSet} event. + +[.contract-item] +[[GovernorProposalGuardian-_setProposalGuardian-address-]] +==== `[.contract-item-name]#++_setProposalGuardian++#++(address newProposalGuardian)++` [.item-kind]#internal# + +Internal setter for the proposal guardian. + +Emits a {ProposalGuardianSet} event. + +[.contract-item] +[[GovernorProposalGuardian-_validateCancel-uint256-address-]] +==== `[.contract-item-name]#++_validateCancel++#++(uint256 proposalId, address caller) → bool++` [.item-kind]#internal# + +Override {Governor-_validateCancel} to implement the extended cancellation logic. + +* The {proposalGuardian} can cancel any proposal at any point. +* If no proposal guardian is set, the {IGovernor-proposalProposer} can cancel their proposals at any point. +* In any case, permissions defined in {Governor-_validateCancel} (or another override) remains valid. + +[.contract-item] +[[GovernorProposalGuardian-ProposalGuardianSet-address-address-]] +==== `[.contract-item-name]#++ProposalGuardianSet++#++(address oldProposalGuardian, address newProposalGuardian)++` [.item-kind]#event# + +:superQuorum: pass:normal[xref:#GovernorSuperQuorum-superQuorum-uint256-[`++superQuorum++`]] +:proposalVotes: pass:normal[xref:#GovernorSuperQuorum-proposalVotes-uint256-[`++proposalVotes++`]] +:state: pass:normal[xref:#GovernorSuperQuorum-state-uint256-[`++state++`]] + +:superQuorum-uint256: pass:normal[xref:#GovernorSuperQuorum-superQuorum-uint256-[`++superQuorum++`]] +:proposalVotes-uint256: pass:normal[xref:#GovernorSuperQuorum-proposalVotes-uint256-[`++proposalVotes++`]] +:state-uint256: pass:normal[xref:#GovernorSuperQuorum-state-uint256-[`++state++`]] + +[.contract] +[[GovernorSuperQuorum]] +=== `++GovernorSuperQuorum++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/extensions/GovernorSuperQuorum.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/governance/extensions/GovernorSuperQuorum.sol"; +``` + +Extension of {Governor} with a super quorum. Proposals that meet the super quorum (and have a majority of for +votes) advance to the `Succeeded` state before the proposal deadline. Counting modules that want to use this +extension must implement {proposalVotes}. + +[.contract-index] +.Functions +-- +* {xref-GovernorSuperQuorum-superQuorum-uint256-}[`++superQuorum(timepoint)++`] +* {xref-GovernorSuperQuorum-proposalVotes-uint256-}[`++proposalVotes(proposalId)++`] +* {xref-GovernorSuperQuorum-state-uint256-}[`++state(proposalId)++`] + +[.contract-subindex-inherited] +.Governor +* {xref-Governor-receive--}[`++receive()++`] +* {xref-Governor-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-Governor-name--}[`++name()++`] +* {xref-Governor-version--}[`++version()++`] +* {xref-Governor-hashProposal-address---uint256---bytes---bytes32-}[`++hashProposal(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getProposalId-address---uint256---bytes---bytes32-}[`++getProposalId(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-proposalThreshold--}[`++proposalThreshold()++`] +* {xref-Governor-proposalSnapshot-uint256-}[`++proposalSnapshot(proposalId)++`] +* {xref-Governor-proposalDeadline-uint256-}[`++proposalDeadline(proposalId)++`] +* {xref-Governor-proposalProposer-uint256-}[`++proposalProposer(proposalId)++`] +* {xref-Governor-proposalEta-uint256-}[`++proposalEta(proposalId)++`] +* {xref-Governor-proposalNeedsQueuing-uint256-}[`++proposalNeedsQueuing()++`] +* {xref-Governor-_checkGovernance--}[`++_checkGovernance()++`] +* {xref-Governor-_quorumReached-uint256-}[`++_quorumReached(proposalId)++`] +* {xref-Governor-_voteSucceeded-uint256-}[`++_voteSucceeded(proposalId)++`] +* {xref-Governor-_getVotes-address-uint256-bytes-}[`++_getVotes(account, timepoint, params)++`] +* {xref-Governor-_countVote-uint256-address-uint8-uint256-bytes-}[`++_countVote(proposalId, account, support, totalWeight, params)++`] +* {xref-Governor-_tallyUpdated-uint256-}[`++_tallyUpdated(proposalId)++`] +* {xref-Governor-_defaultParams--}[`++_defaultParams()++`] +* {xref-Governor-propose-address---uint256---bytes---string-}[`++propose(targets, values, calldatas, description)++`] +* {xref-Governor-_propose-address---uint256---bytes---string-address-}[`++_propose(targets, values, calldatas, description, proposer)++`] +* {xref-Governor-queue-address---uint256---bytes---bytes32-}[`++queue(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_queueOperations-uint256-address---uint256---bytes---bytes32-}[`++_queueOperations(, , , , )++`] +* {xref-Governor-execute-address---uint256---bytes---bytes32-}[`++execute(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_executeOperations-uint256-address---uint256---bytes---bytes32-}[`++_executeOperations(, targets, values, calldatas, )++`] +* {xref-Governor-cancel-address---uint256---bytes---bytes32-}[`++cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-_cancel-address---uint256---bytes---bytes32-}[`++_cancel(targets, values, calldatas, descriptionHash)++`] +* {xref-Governor-getVotes-address-uint256-}[`++getVotes(account, timepoint)++`] +* {xref-Governor-getVotesWithParams-address-uint256-bytes-}[`++getVotesWithParams(account, timepoint, params)++`] +* {xref-Governor-castVote-uint256-uint8-}[`++castVote(proposalId, support)++`] +* {xref-Governor-castVoteWithReason-uint256-uint8-string-}[`++castVoteWithReason(proposalId, support, reason)++`] +* {xref-Governor-castVoteWithReasonAndParams-uint256-uint8-string-bytes-}[`++castVoteWithReasonAndParams(proposalId, support, reason, params)++`] +* {xref-Governor-castVoteBySig-uint256-uint8-address-bytes-}[`++castVoteBySig(proposalId, support, voter, signature)++`] +* {xref-Governor-castVoteWithReasonAndParamsBySig-uint256-uint8-address-string-bytes-bytes-}[`++castVoteWithReasonAndParamsBySig(proposalId, support, voter, reason, params, signature)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-}[`++_castVote(proposalId, account, support, reason)++`] +* {xref-Governor-_castVote-uint256-address-uint8-string-bytes-}[`++_castVote(proposalId, account, support, reason, params)++`] +* {xref-Governor-relay-address-uint256-bytes-}[`++relay(target, value, data)++`] +* {xref-Governor-_executor--}[`++_executor()++`] +* {xref-Governor-onERC721Received-address-address-uint256-bytes-}[`++onERC721Received(, , , )++`] +* {xref-Governor-onERC1155Received-address-address-uint256-uint256-bytes-}[`++onERC1155Received(, , , , )++`] +* {xref-Governor-onERC1155BatchReceived-address-address-uint256---uint256---bytes-}[`++onERC1155BatchReceived(, , , , )++`] +* {xref-Governor-_encodeStateBitmap-enum-IGovernor-ProposalState-}[`++_encodeStateBitmap(proposalState)++`] +* {xref-Governor-_validateStateBitmap-uint256-bytes32-}[`++_validateStateBitmap(proposalId, allowedStates)++`] +* {xref-Governor-_isValidDescriptionForProposer-address-string-}[`++_isValidDescriptionForProposer(proposer, description)++`] +* {xref-Governor-_validateCancel-uint256-address-}[`++_validateCancel(proposalId, caller)++`] +* {xref-Governor-clock--}[`++clock()++`] +* {xref-Governor-CLOCK_MODE--}[`++CLOCK_MODE()++`] +* {xref-Governor-votingDelay--}[`++votingDelay()++`] +* {xref-Governor-votingPeriod--}[`++votingPeriod()++`] +* {xref-Governor-quorum-uint256-}[`++quorum(timepoint)++`] +* {xref-Governor-BALLOT_TYPEHASH-bytes32}[`++BALLOT_TYPEHASH()++`] +* {xref-Governor-EXTENDED_BALLOT_TYPEHASH-bytes32}[`++EXTENDED_BALLOT_TYPEHASH()++`] + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-COUNTING_MODE--}[`++COUNTING_MODE()++`] +* {xref-IGovernor-hasVoted-uint256-address-}[`++hasVoted(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-nonces-address-}[`++nonces(owner)++`] +* {xref-Nonces-_useNonce-address-}[`++_useNonce(owner)++`] +* {xref-Nonces-_useCheckedNonce-address-uint256-}[`++_useCheckedNonce(owner, nonce)++`] + +[.contract-subindex-inherited] +.EIP712 +* {xref-EIP712-_domainSeparatorV4--}[`++_domainSeparatorV4()++`] +* {xref-EIP712-_hashTypedDataV4-bytes32-}[`++_hashTypedDataV4(structHash)++`] +* {xref-EIP712-eip712Domain--}[`++eip712Domain()++`] +* {xref-EIP712-_EIP712Name--}[`++_EIP712Name()++`] +* {xref-EIP712-_EIP712Version--}[`++_EIP712Version()++`] + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-ProposalCreated-uint256-address-address---uint256---string---bytes---uint256-uint256-string-}[`++ProposalCreated(proposalId, proposer, targets, values, signatures, calldatas, voteStart, voteEnd, description)++`] +* {xref-IGovernor-ProposalQueued-uint256-uint256-}[`++ProposalQueued(proposalId, etaSeconds)++`] +* {xref-IGovernor-ProposalExecuted-uint256-}[`++ProposalExecuted(proposalId)++`] +* {xref-IGovernor-ProposalCanceled-uint256-}[`++ProposalCanceled(proposalId)++`] +* {xref-IGovernor-VoteCast-address-uint256-uint8-uint256-string-}[`++VoteCast(voter, proposalId, support, weight, reason)++`] +* {xref-IGovernor-VoteCastWithParams-address-uint256-uint8-uint256-string-bytes-}[`++VoteCastWithParams(voter, proposalId, support, weight, reason, params)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 +* {xref-IERC5267-EIP712DomainChanged--}[`++EIP712DomainChanged()++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- + +[.contract-subindex-inherited] +.Governor + +[.contract-subindex-inherited] +.IERC1155Receiver + +[.contract-subindex-inherited] +.IERC721Receiver + +[.contract-subindex-inherited] +.IGovernor +* {xref-IGovernor-GovernorInvalidProposalLength-uint256-uint256-uint256-}[`++GovernorInvalidProposalLength(targets, calldatas, values)++`] +* {xref-IGovernor-GovernorAlreadyCastVote-address-}[`++GovernorAlreadyCastVote(voter)++`] +* {xref-IGovernor-GovernorDisabledDeposit--}[`++GovernorDisabledDeposit()++`] +* {xref-IGovernor-GovernorOnlyExecutor-address-}[`++GovernorOnlyExecutor(account)++`] +* {xref-IGovernor-GovernorNonexistentProposal-uint256-}[`++GovernorNonexistentProposal(proposalId)++`] +* {xref-IGovernor-GovernorUnexpectedProposalState-uint256-enum-IGovernor-ProposalState-bytes32-}[`++GovernorUnexpectedProposalState(proposalId, current, expectedStates)++`] +* {xref-IGovernor-GovernorInvalidVotingPeriod-uint256-}[`++GovernorInvalidVotingPeriod(votingPeriod)++`] +* {xref-IGovernor-GovernorInsufficientProposerVotes-address-uint256-uint256-}[`++GovernorInsufficientProposerVotes(proposer, votes, threshold)++`] +* {xref-IGovernor-GovernorRestrictedProposer-address-}[`++GovernorRestrictedProposer(proposer)++`] +* {xref-IGovernor-GovernorInvalidVoteType--}[`++GovernorInvalidVoteType()++`] +* {xref-IGovernor-GovernorInvalidVoteParams--}[`++GovernorInvalidVoteParams()++`] +* {xref-IGovernor-GovernorQueueNotImplemented--}[`++GovernorQueueNotImplemented()++`] +* {xref-IGovernor-GovernorNotQueuedProposal-uint256-}[`++GovernorNotQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorAlreadyQueuedProposal-uint256-}[`++GovernorAlreadyQueuedProposal(proposalId)++`] +* {xref-IGovernor-GovernorInvalidSignature-address-}[`++GovernorInvalidSignature(voter)++`] +* {xref-IGovernor-GovernorUnableToCancel-uint256-address-}[`++GovernorUnableToCancel(proposalId, account)++`] + +[.contract-subindex-inherited] +.IERC6372 + +[.contract-subindex-inherited] +.Nonces +* {xref-Nonces-InvalidAccountNonce-address-uint256-}[`++InvalidAccountNonce(account, currentNonce)++`] + +[.contract-subindex-inherited] +.EIP712 + +[.contract-subindex-inherited] +.IERC5267 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[GovernorSuperQuorum-superQuorum-uint256-]] +==== `[.contract-item-name]#++superQuorum++#++(uint256 timepoint) → uint256++` [.item-kind]#public# + +Minimum number of cast votes required for a proposal to reach super quorum. Only FOR votes are counted +towards the super quorum. Once the super quorum is reached, an active proposal can proceed to the next state +without waiting for the proposal deadline. + +NOTE: The `timepoint` parameter corresponds to the snapshot used for counting the vote. This enables scaling of the +quorum depending on values such as the `totalSupply` of a token at this timepoint (see {ERC20Votes}). + +NOTE: Make sure the value specified for the super quorum is greater than {quorum}, otherwise, it may be +possible to pass a proposal with less votes than the default quorum. + +[.contract-item] +[[GovernorSuperQuorum-proposalVotes-uint256-]] +==== `[.contract-item-name]#++proposalVotes++#++(uint256 proposalId) → uint256 againstVotes, uint256 forVotes, uint256 abstainVotes++` [.item-kind]#public# + +Accessor to the internal vote counts. This must be implemented by the counting module. Counting modules +that don't implement this function are incompatible with this module + +[.contract-item] +[[GovernorSuperQuorum-state-uint256-]] +==== `[.contract-item-name]#++state++#++(uint256 proposalId) → enum IGovernor.ProposalState++` [.item-kind]#public# + +Overridden version of the {Governor-state} function that checks if the proposal has reached the super +quorum. + +NOTE: If the proposal reaches super quorum but {_voteSucceeded} returns false, eg, assuming the super quorum +has been set low enough that both FOR and AGAINST votes have exceeded it and AGAINST votes exceed FOR votes, +the proposal continues to be active until {_voteSucceeded} returns true or the proposal deadline is reached. +This means that with a low super quorum it is also possible that a vote can succeed prematurely before enough +AGAINST voters have a chance to vote. Hence, it is recommended to set a high enough super quorum to avoid these +types of scenarios. + == Utils :ERC6372InconsistentClock: pass:normal[xref:#Votes-ERC6372InconsistentClock--[`++ERC6372InconsistentClock++`]] @@ -5586,9 +7504,26 @@ Returns the details (including the proposalId) of a proposal given its sequentia :_checkpoints: pass:normal[xref:#Votes-_checkpoints-address-uint32-[`++_checkpoints++`]] :_getVotingUnits: pass:normal[xref:#Votes-_getVotingUnits-address-[`++_getVotingUnits++`]] +:clock-: pass:normal[xref:#Votes-clock--[`++clock++`]] +:CLOCK_MODE-: pass:normal[xref:#Votes-CLOCK_MODE--[`++CLOCK_MODE++`]] +:_validateTimepoint-uint256: pass:normal[xref:#Votes-_validateTimepoint-uint256-[`++_validateTimepoint++`]] +:getVotes-address: pass:normal[xref:#Votes-getVotes-address-[`++getVotes++`]] +:getPastVotes-address-uint256: pass:normal[xref:#Votes-getPastVotes-address-uint256-[`++getPastVotes++`]] +:getPastTotalSupply-uint256: pass:normal[xref:#Votes-getPastTotalSupply-uint256-[`++getPastTotalSupply++`]] +:_getTotalSupply-: pass:normal[xref:#Votes-_getTotalSupply--[`++_getTotalSupply++`]] +:delegates-address: pass:normal[xref:#Votes-delegates-address-[`++delegates++`]] +:delegate-address: pass:normal[xref:#Votes-delegate-address-[`++delegate++`]] +:delegateBySig-address-uint256-uint256-uint8-bytes32-bytes32: pass:normal[xref:#Votes-delegateBySig-address-uint256-uint256-uint8-bytes32-bytes32-[`++delegateBySig++`]] +:_delegate-address-address: pass:normal[xref:#Votes-_delegate-address-address-[`++_delegate++`]] +:_transferVotingUnits-address-address-uint256: pass:normal[xref:#Votes-_transferVotingUnits-address-address-uint256-[`++_transferVotingUnits++`]] +:_moveDelegateVotes-address-address-uint256: pass:normal[xref:#Votes-_moveDelegateVotes-address-address-uint256-[`++_moveDelegateVotes++`]] +:_numCheckpoints-address: pass:normal[xref:#Votes-_numCheckpoints-address-[`++_numCheckpoints++`]] +:_checkpoints-address-uint32: pass:normal[xref:#Votes-_checkpoints-address-uint32-[`++_checkpoints++`]] +:_getVotingUnits-address: pass:normal[xref:#Votes-_getVotingUnits-address-[`++_getVotingUnits++`]] + [.contract] [[Votes]] -=== `++Votes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/utils/Votes.sol[{github-icon},role=heading-link] +=== `++Votes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/utils/Votes.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5846,9 +7781,14 @@ Lookup to future votes is not available. :_delegate: pass:normal[xref:#VotesExtended-_delegate-address-address-[`++_delegate++`]] :_transferVotingUnits: pass:normal[xref:#VotesExtended-_transferVotingUnits-address-address-uint256-[`++_transferVotingUnits++`]] +:getPastDelegate-address-uint256: pass:normal[xref:#VotesExtended-getPastDelegate-address-uint256-[`++getPastDelegate++`]] +:getPastBalanceOf-address-uint256: pass:normal[xref:#VotesExtended-getPastBalanceOf-address-uint256-[`++getPastBalanceOf++`]] +:_delegate-address-address: pass:normal[xref:#VotesExtended-_delegate-address-address-[`++_delegate++`]] +:_transferVotingUnits-address-address-uint256: pass:normal[xref:#VotesExtended-_transferVotingUnits-address-address-uint256-[`++_transferVotingUnits++`]] + [.contract] [[VotesExtended]] -=== `++VotesExtended++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/utils/VotesExtended.sol[{github-icon},role=heading-link] +=== `++VotesExtended++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/utils/VotesExtended.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6071,9 +8011,33 @@ In a governance system, the {TimelockController} contract is in charge of introd :updateDelay: pass:normal[xref:#TimelockController-updateDelay-uint256-[`++updateDelay++`]] :_encodeStateBitmap: pass:normal[xref:#TimelockController-_encodeStateBitmap-enum-TimelockController-OperationState-[`++_encodeStateBitmap++`]] +:constructor-uint256-address---address---address: pass:normal[xref:#TimelockController-constructor-uint256-address---address---address-[`++constructor++`]] +:receive-: pass:normal[xref:#TimelockController-receive--[`++receive++`]] +:supportsInterface-bytes4: pass:normal[xref:#TimelockController-supportsInterface-bytes4-[`++supportsInterface++`]] +:isOperation-bytes32: pass:normal[xref:#TimelockController-isOperation-bytes32-[`++isOperation++`]] +:isOperationPending-bytes32: pass:normal[xref:#TimelockController-isOperationPending-bytes32-[`++isOperationPending++`]] +:isOperationReady-bytes32: pass:normal[xref:#TimelockController-isOperationReady-bytes32-[`++isOperationReady++`]] +:isOperationDone-bytes32: pass:normal[xref:#TimelockController-isOperationDone-bytes32-[`++isOperationDone++`]] +:getTimestamp-bytes32: pass:normal[xref:#TimelockController-getTimestamp-bytes32-[`++getTimestamp++`]] +:getOperationState-bytes32: pass:normal[xref:#TimelockController-getOperationState-bytes32-[`++getOperationState++`]] +:getMinDelay-: pass:normal[xref:#TimelockController-getMinDelay--[`++getMinDelay++`]] +:hashOperation-address-uint256-bytes-bytes32-bytes32: pass:normal[xref:#TimelockController-hashOperation-address-uint256-bytes-bytes32-bytes32-[`++hashOperation++`]] +:hashOperationBatch-address---uint256---bytes---bytes32-bytes32: pass:normal[xref:#TimelockController-hashOperationBatch-address---uint256---bytes---bytes32-bytes32-[`++hashOperationBatch++`]] +:schedule-address-uint256-bytes-bytes32-bytes32-uint256: pass:normal[xref:#TimelockController-schedule-address-uint256-bytes-bytes32-bytes32-uint256-[`++schedule++`]] +:scheduleBatch-address---uint256---bytes---bytes32-bytes32-uint256: pass:normal[xref:#TimelockController-scheduleBatch-address---uint256---bytes---bytes32-bytes32-uint256-[`++scheduleBatch++`]] +:cancel-bytes32: pass:normal[xref:#TimelockController-cancel-bytes32-[`++cancel++`]] +:execute-address-uint256-bytes-bytes32-bytes32: pass:normal[xref:#TimelockController-execute-address-uint256-bytes-bytes32-bytes32-[`++execute++`]] +:executeBatch-address---uint256---bytes---bytes32-bytes32: pass:normal[xref:#TimelockController-executeBatch-address---uint256---bytes---bytes32-bytes32-[`++executeBatch++`]] +:_execute-address-uint256-bytes: pass:normal[xref:#TimelockController-_execute-address-uint256-bytes-[`++_execute++`]] +:updateDelay-uint256: pass:normal[xref:#TimelockController-updateDelay-uint256-[`++updateDelay++`]] +:_encodeStateBitmap-enum-TimelockController-OperationState: pass:normal[xref:#TimelockController-_encodeStateBitmap-enum-TimelockController-OperationState-[`++_encodeStateBitmap++`]] +:PROPOSER_ROLE-bytes32: pass:normal[xref:#TimelockController-PROPOSER_ROLE-bytes32[`++PROPOSER_ROLE++`]] +:EXECUTOR_ROLE-bytes32: pass:normal[xref:#TimelockController-EXECUTOR_ROLE-bytes32[`++EXECUTOR_ROLE++`]] +:CANCELLER_ROLE-bytes32: pass:normal[xref:#TimelockController-CANCELLER_ROLE-bytes32[`++CANCELLER_ROLE++`]] + [.contract] [[TimelockController]] -=== `++TimelockController++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/governance/TimelockController.sol[{github-icon},role=heading-link] +=== `++TimelockController++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/governance/TimelockController.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6542,7 +8506,7 @@ The caller account is not authorized. [[timelock-terminology]] ==== Terminology -* *Operation:* A transaction (or a set of transactions) that is the subject of the timelock. It has to be scheduled by a proposer and executed by an executor. The timelock enforces a minimum delay between the proposition and the execution (see xref:access-control.adoc#operation_lifecycle[operation lifecycle]). If the operation contains multiple transactions (batch mode), they are executed atomically. Operations are identified by the hash of their content. +* *Operation:* A transaction (or a set of transactions) that is the subject of the timelock. It has to be scheduled by a proposer and executed by an executor. The timelock enforces a minimum delay between the proposition and the execution. If the operation contains multiple transactions (batch mode), they are executed atomically. Operations are identified by the hash of their content. * *Operation status:* ** *Unset:* An operation that is not part of the timelock mechanism. ** *Waiting:* An operation that has been scheduled, before the timer expires. diff --git a/docs/modules/api/pages/interfaces.adoc b/docs/modules/api/pages/interfaces.adoc index 4760ff5bb..187be49da 100644 --- a/docs/modules/api/pages/interfaces.adoc +++ b/docs/modules/api/pages/interfaces.adoc @@ -32,6 +32,10 @@ :IERC5313: pass:normal[xref:interfaces.adoc#IERC5313[`IERC5313`]] :IERC5805: pass:normal[xref:interfaces.adoc#IERC5805[`IERC5805`]] :IERC6372: pass:normal[xref:interfaces.adoc#IERC6372[`IERC6372`]] +:IERC6909: pass:normal[xref:interfaces.adoc#IERC6909[`IERC6909`]] +:IERC6909ContentURI: pass:normal[xref:interfaces.adoc#IERC6909ContentURI[`IERC6909ContentURI`]] +:IERC6909Metadata: pass:normal[xref:interfaces.adoc#IERC6909Metadata[`IERC6909Metadata`]] +:IERC6909TokenSupply: pass:normal[xref:interfaces.adoc#IERC6909TokenSupply[`IERC6909TokenSupply`]] :IERC7674: pass:normal[xref:interfaces.adoc#IERC7674[`IERC7674`]] :xref-IERC20Errors-ERC20InsufficientBalance-address-uint256-uint256-: xref:interfaces.adoc#IERC20Errors-ERC20InsufficientBalance-address-uint256-uint256- :xref-IERC20Errors-ERC20InvalidSender-address-: xref:interfaces.adoc#IERC20Errors-ERC20InvalidSender-address- @@ -135,9 +139,24 @@ :xref-IERC4626-Withdraw-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC4626-Withdraw-address-address-address-uint256-uint256- :xref-IERC20-Transfer-address-address-uint256-: xref:token/ERC20.adoc#IERC20-Transfer-address-address-uint256- :xref-IERC20-Approval-address-address-uint256-: xref:token/ERC20.adoc#IERC20-Approval-address-address-uint256- -:xref-IERC5313-owner--: xref:interfaces.adoc#IERC5313-owner-- +:xref-IERC721-balanceOf-address-: xref:token/ERC721.adoc#IERC721-balanceOf-address- +:xref-IERC721-ownerOf-uint256-: xref:token/ERC721.adoc#IERC721-ownerOf-uint256- +:xref-IERC721-safeTransferFrom-address-address-uint256-bytes-: xref:token/ERC721.adoc#IERC721-safeTransferFrom-address-address-uint256-bytes- +:xref-IERC721-safeTransferFrom-address-address-uint256-: xref:token/ERC721.adoc#IERC721-safeTransferFrom-address-address-uint256- +:xref-IERC721-transferFrom-address-address-uint256-: xref:token/ERC721.adoc#IERC721-transferFrom-address-address-uint256- +:xref-IERC721-approve-address-uint256-: xref:token/ERC721.adoc#IERC721-approve-address-uint256- +:xref-IERC721-setApprovalForAll-address-bool-: xref:token/ERC721.adoc#IERC721-setApprovalForAll-address-bool- +:xref-IERC721-getApproved-uint256-: xref:token/ERC721.adoc#IERC721-getApproved-uint256- +:xref-IERC721-isApprovedForAll-address-address-: xref:token/ERC721.adoc#IERC721-isApprovedForAll-address-address- +:xref-IERC165-supportsInterface-bytes4-: xref:utils.adoc#IERC165-supportsInterface-bytes4- +:xref-IERC4906-MetadataUpdate-uint256-: xref:interfaces.adoc#IERC4906-MetadataUpdate-uint256- +:xref-IERC4906-BatchMetadataUpdate-uint256-uint256-: xref:interfaces.adoc#IERC4906-BatchMetadataUpdate-uint256-uint256- +:xref-IERC721-Transfer-address-address-uint256-: xref:token/ERC721.adoc#IERC721-Transfer-address-address-uint256- +:xref-IERC721-Approval-address-address-uint256-: xref:token/ERC721.adoc#IERC721-Approval-address-address-uint256- +:xref-IERC721-ApprovalForAll-address-address-bool-: xref:token/ERC721.adoc#IERC721-ApprovalForAll-address-address-bool- :xref-IERC5267-eip712Domain--: xref:interfaces.adoc#IERC5267-eip712Domain-- :xref-IERC5267-EIP712DomainChanged--: xref:interfaces.adoc#IERC5267-EIP712DomainChanged-- +:xref-IERC5313-owner--: xref:interfaces.adoc#IERC5313-owner-- :xref-IVotes-getVotes-address-: xref:governance.adoc#IVotes-getVotes-address- :xref-IVotes-getPastVotes-address-uint256-: xref:governance.adoc#IVotes-getPastVotes-address-uint256- :xref-IVotes-getPastTotalSupply-uint256-: xref:governance.adoc#IVotes-getPastTotalSupply-uint256- @@ -151,6 +170,59 @@ :xref-IVotes-VotesExpiredSignature-uint256-: xref:governance.adoc#IVotes-VotesExpiredSignature-uint256- :xref-IERC6372-clock--: xref:interfaces.adoc#IERC6372-clock-- :xref-IERC6372-CLOCK_MODE--: xref:interfaces.adoc#IERC6372-CLOCK_MODE-- +:xref-IERC6909-balanceOf-address-uint256-: xref:interfaces.adoc#IERC6909-balanceOf-address-uint256- +:xref-IERC6909-allowance-address-address-uint256-: xref:interfaces.adoc#IERC6909-allowance-address-address-uint256- +:xref-IERC6909-isOperator-address-address-: xref:interfaces.adoc#IERC6909-isOperator-address-address- +:xref-IERC6909-approve-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-approve-address-uint256-uint256- +:xref-IERC6909-setOperator-address-bool-: xref:interfaces.adoc#IERC6909-setOperator-address-bool- +:xref-IERC6909-transfer-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transfer-address-uint256-uint256- +:xref-IERC6909-transferFrom-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transferFrom-address-address-uint256-uint256- +:xref-IERC165-supportsInterface-bytes4-: xref:utils.adoc#IERC165-supportsInterface-bytes4- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:IERC6909: pass:normal[xref:interfaces.adoc#IERC6909[`IERC6909`]] +:xref-IERC6909ContentURI-contractURI--: xref:interfaces.adoc#IERC6909ContentURI-contractURI-- +:xref-IERC6909ContentURI-tokenURI-uint256-: xref:interfaces.adoc#IERC6909ContentURI-tokenURI-uint256- +:xref-IERC6909-balanceOf-address-uint256-: xref:interfaces.adoc#IERC6909-balanceOf-address-uint256- +:xref-IERC6909-allowance-address-address-uint256-: xref:interfaces.adoc#IERC6909-allowance-address-address-uint256- +:xref-IERC6909-isOperator-address-address-: xref:interfaces.adoc#IERC6909-isOperator-address-address- +:xref-IERC6909-approve-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-approve-address-uint256-uint256- +:xref-IERC6909-setOperator-address-bool-: xref:interfaces.adoc#IERC6909-setOperator-address-bool- +:xref-IERC6909-transfer-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transfer-address-uint256-uint256- +:xref-IERC6909-transferFrom-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transferFrom-address-address-uint256-uint256- +:xref-IERC165-supportsInterface-bytes4-: xref:utils.adoc#IERC165-supportsInterface-bytes4- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:IERC6909: pass:normal[xref:interfaces.adoc#IERC6909[`IERC6909`]] +:xref-IERC6909Metadata-name-uint256-: xref:interfaces.adoc#IERC6909Metadata-name-uint256- +:xref-IERC6909Metadata-symbol-uint256-: xref:interfaces.adoc#IERC6909Metadata-symbol-uint256- +:xref-IERC6909Metadata-decimals-uint256-: xref:interfaces.adoc#IERC6909Metadata-decimals-uint256- +:xref-IERC6909-balanceOf-address-uint256-: xref:interfaces.adoc#IERC6909-balanceOf-address-uint256- +:xref-IERC6909-allowance-address-address-uint256-: xref:interfaces.adoc#IERC6909-allowance-address-address-uint256- +:xref-IERC6909-isOperator-address-address-: xref:interfaces.adoc#IERC6909-isOperator-address-address- +:xref-IERC6909-approve-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-approve-address-uint256-uint256- +:xref-IERC6909-setOperator-address-bool-: xref:interfaces.adoc#IERC6909-setOperator-address-bool- +:xref-IERC6909-transfer-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transfer-address-uint256-uint256- +:xref-IERC6909-transferFrom-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transferFrom-address-address-uint256-uint256- +:xref-IERC165-supportsInterface-bytes4-: xref:utils.adoc#IERC165-supportsInterface-bytes4- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:IERC6909: pass:normal[xref:interfaces.adoc#IERC6909[`IERC6909`]] +:xref-IERC6909TokenSupply-totalSupply-uint256-: xref:interfaces.adoc#IERC6909TokenSupply-totalSupply-uint256- +:xref-IERC6909-balanceOf-address-uint256-: xref:interfaces.adoc#IERC6909-balanceOf-address-uint256- +:xref-IERC6909-allowance-address-address-uint256-: xref:interfaces.adoc#IERC6909-allowance-address-address-uint256- +:xref-IERC6909-isOperator-address-address-: xref:interfaces.adoc#IERC6909-isOperator-address-address- +:xref-IERC6909-approve-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-approve-address-uint256-uint256- +:xref-IERC6909-setOperator-address-bool-: xref:interfaces.adoc#IERC6909-setOperator-address-bool- +:xref-IERC6909-transfer-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transfer-address-uint256-uint256- +:xref-IERC6909-transferFrom-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-transferFrom-address-address-uint256-uint256- +:xref-IERC165-supportsInterface-bytes4-: xref:utils.adoc#IERC165-supportsInterface-bytes4- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- :xref-IERC7674-temporaryApprove-address-uint256-: xref:interfaces.adoc#IERC7674-temporaryApprove-address-uint256- :xref-IERC20-totalSupply--: xref:token/ERC20.adoc#IERC20-totalSupply-- :xref-IERC20-balanceOf-address-: xref:token/ERC20.adoc#IERC20-balanceOf-address- @@ -202,6 +274,10 @@ are useful to interact with third party contracts that implement them. - {IERC5313} - {IERC5805} - {IERC6372} +- {IERC6909} +- {IERC6909ContentURI} +- {IERC6909Metadata} +- {IERC6909TokenSupply} - {IERC7674} == Detailed ABI @@ -215,7 +291,7 @@ are useful to interact with third party contracts that implement them. [.contract] [[IERC20Errors]] -=== `++IERC20Errors++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/draft-IERC6093.sol[{github-icon},role=heading-link] +=== `++IERC20Errors++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6093.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -284,7 +360,7 @@ Indicates a failure with the `spender` to be approved. Used in approvals. [.contract] [[IERC721Errors]] -=== `++IERC721Errors++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/draft-IERC6093.sol[{github-icon},role=heading-link] +=== `++IERC721Errors++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6093.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -367,7 +443,7 @@ Indicates a failure with the `operator` to be approved. Used in approvals. [.contract] [[IERC1155Errors]] -=== `++IERC1155Errors++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/draft-IERC6093.sol[{github-icon},role=heading-link] +=== `++IERC1155Errors++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6093.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -435,9 +511,11 @@ Used in batch transfers. :isValidSignature: pass:normal[xref:#IERC1271-isValidSignature-bytes32-bytes-[`++isValidSignature++`]] +:isValidSignature-bytes32-bytes: pass:normal[xref:#IERC1271-isValidSignature-bytes32-bytes-[`++isValidSignature++`]] + [.contract] [[IERC1271]] -=== `++IERC1271++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC1271.sol[{github-icon},role=heading-link] +=== `++IERC1271++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC1271.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -467,9 +545,16 @@ Should return whether the signature provided is valid for the provided data :approveAndCall: pass:normal[xref:#IERC1363-approveAndCall-address-uint256-[`++approveAndCall++`]] :approveAndCall: pass:normal[xref:#IERC1363-approveAndCall-address-uint256-bytes-[`++approveAndCall++`]] +:transferAndCall-address-uint256: pass:normal[xref:#IERC1363-transferAndCall-address-uint256-[`++transferAndCall++`]] +:transferAndCall-address-uint256-bytes: pass:normal[xref:#IERC1363-transferAndCall-address-uint256-bytes-[`++transferAndCall++`]] +:transferFromAndCall-address-address-uint256: pass:normal[xref:#IERC1363-transferFromAndCall-address-address-uint256-[`++transferFromAndCall++`]] +:transferFromAndCall-address-address-uint256-bytes: pass:normal[xref:#IERC1363-transferFromAndCall-address-address-uint256-bytes-[`++transferFromAndCall++`]] +:approveAndCall-address-uint256: pass:normal[xref:#IERC1363-approveAndCall-address-uint256-[`++approveAndCall++`]] +:approveAndCall-address-uint256-bytes: pass:normal[xref:#IERC1363-approveAndCall-address-uint256-bytes-[`++approveAndCall++`]] + [.contract] [[IERC1363]] -=== `++IERC1363++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC1363.sol[{github-icon},role=heading-link] +=== `++IERC1363++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC1363.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -564,9 +649,11 @@ caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender` :onTransferReceived: pass:normal[xref:#IERC1363Receiver-onTransferReceived-address-address-uint256-bytes-[`++onTransferReceived++`]] +:onTransferReceived-address-address-uint256-bytes: pass:normal[xref:#IERC1363Receiver-onTransferReceived-address-address-uint256-bytes-[`++onTransferReceived++`]] + [.contract] [[IERC1363Receiver]] -=== `++IERC1363Receiver++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC1363Receiver.sol[{github-icon},role=heading-link] +=== `++IERC1363Receiver++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC1363Receiver.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -596,9 +683,11 @@ NOTE: To accept the transfer, this must return :onApprovalReceived: pass:normal[xref:#IERC1363Spender-onApprovalReceived-address-uint256-bytes-[`++onApprovalReceived++`]] +:onApprovalReceived-address-uint256-bytes: pass:normal[xref:#IERC1363Spender-onApprovalReceived-address-uint256-bytes-[`++onApprovalReceived++`]] + [.contract] [[IERC1363Spender]] -=== `++IERC1363Spender++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC1363Spender.sol[{github-icon},role=heading-link] +=== `++IERC1363Spender++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC1363Spender.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -628,9 +717,11 @@ NOTE: To accept the approval, this must return :canImplementInterfaceForAddress: pass:normal[xref:#IERC1820Implementer-canImplementInterfaceForAddress-bytes32-address-[`++canImplementInterfaceForAddress++`]] +:canImplementInterfaceForAddress-bytes32-address: pass:normal[xref:#IERC1820Implementer-canImplementInterfaceForAddress-bytes32-address-[`++canImplementInterfaceForAddress++`]] + [.contract] [[IERC1820Implementer]] -=== `++IERC1820Implementer++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC1820Implementer.sol[{github-icon},role=heading-link] +=== `++IERC1820Implementer++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC1820Implementer.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -669,9 +760,18 @@ See {IERC1820Registry-setInterfaceImplementer}. :implementsERC165Interface: pass:normal[xref:#IERC1820Registry-implementsERC165Interface-address-bytes4-[`++implementsERC165Interface++`]] :implementsERC165InterfaceNoCache: pass:normal[xref:#IERC1820Registry-implementsERC165InterfaceNoCache-address-bytes4-[`++implementsERC165InterfaceNoCache++`]] +:setManager-address-address: pass:normal[xref:#IERC1820Registry-setManager-address-address-[`++setManager++`]] +:getManager-address: pass:normal[xref:#IERC1820Registry-getManager-address-[`++getManager++`]] +:setInterfaceImplementer-address-bytes32-address: pass:normal[xref:#IERC1820Registry-setInterfaceImplementer-address-bytes32-address-[`++setInterfaceImplementer++`]] +:getInterfaceImplementer-address-bytes32: pass:normal[xref:#IERC1820Registry-getInterfaceImplementer-address-bytes32-[`++getInterfaceImplementer++`]] +:interfaceHash-string: pass:normal[xref:#IERC1820Registry-interfaceHash-string-[`++interfaceHash++`]] +:updateERC165Cache-address-bytes4: pass:normal[xref:#IERC1820Registry-updateERC165Cache-address-bytes4-[`++updateERC165Cache++`]] +:implementsERC165Interface-address-bytes4: pass:normal[xref:#IERC1820Registry-implementsERC165Interface-address-bytes4-[`++implementsERC165Interface++`]] +:implementsERC165InterfaceNoCache-address-bytes4: pass:normal[xref:#IERC1820Registry-implementsERC165InterfaceNoCache-address-bytes4-[`++implementsERC165InterfaceNoCache++`]] + [.contract] [[IERC1820Registry]] -=== `++IERC1820Registry++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC1820Registry.sol[{github-icon},role=heading-link] +=== `++IERC1820Registry++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC1820Registry.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -802,9 +902,11 @@ https://eips.ethereum.org/EIPS/eip-1820#interface-name[section of the ERC]. :proxiableUUID: pass:normal[xref:#IERC1822Proxiable-proxiableUUID--[`++proxiableUUID++`]] +:proxiableUUID-: pass:normal[xref:#IERC1822Proxiable-proxiableUUID--[`++proxiableUUID++`]] + [.contract] [[IERC1822Proxiable]] -=== `++IERC1822Proxiable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/draft-IERC1822.sol[{github-icon},role=heading-link] +=== `++IERC1822Proxiable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC1822.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -834,7 +936,7 @@ function revert if invoked through a proxy. [.contract] [[IERC2612]] -=== `++IERC2612++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC2612.sol[{github-icon},role=heading-link] +=== `++IERC2612++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC2612.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -855,9 +957,11 @@ import "@openzeppelin/contracts/interfaces/IERC2612.sol"; :royaltyInfo: pass:normal[xref:#IERC2981-royaltyInfo-uint256-uint256-[`++royaltyInfo++`]] +:royaltyInfo-uint256-uint256: pass:normal[xref:#IERC2981-royaltyInfo-uint256-uint256-[`++royaltyInfo++`]] + [.contract] [[IERC2981]] -=== `++IERC2981++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC2981.sol[{github-icon},role=heading-link] +=== `++IERC2981++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC2981.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -894,9 +998,13 @@ royalty receiver and 0 tokens to the seller. Contracts dealing with royalty shou :flashFee: pass:normal[xref:#IERC3156FlashLender-flashFee-address-uint256-[`++flashFee++`]] :flashLoan: pass:normal[xref:#IERC3156FlashLender-flashLoan-contract-IERC3156FlashBorrower-address-uint256-bytes-[`++flashLoan++`]] +:maxFlashLoan-address: pass:normal[xref:#IERC3156FlashLender-maxFlashLoan-address-[`++maxFlashLoan++`]] +:flashFee-address-uint256: pass:normal[xref:#IERC3156FlashLender-flashFee-address-uint256-[`++flashFee++`]] +:flashLoan-contract-IERC3156FlashBorrower-address-uint256-bytes: pass:normal[xref:#IERC3156FlashLender-flashLoan-contract-IERC3156FlashBorrower-address-uint256-bytes-[`++flashLoan++`]] + [.contract] [[IERC3156FlashLender]] -=== `++IERC3156FlashLender++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC3156FlashLender.sol[{github-icon},role=heading-link] +=== `++IERC3156FlashLender++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC3156FlashLender.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -935,9 +1043,11 @@ Initiate a flash loan. :onFlashLoan: pass:normal[xref:#IERC3156FlashBorrower-onFlashLoan-address-address-uint256-uint256-bytes-[`++onFlashLoan++`]] +:onFlashLoan-address-address-uint256-uint256-bytes: pass:normal[xref:#IERC3156FlashBorrower-onFlashLoan-address-address-uint256-uint256-bytes-[`++onFlashLoan++`]] + [.contract] [[IERC3156FlashBorrower]] -=== `++IERC3156FlashBorrower++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC3156FlashBorrower.sol[{github-icon},role=heading-link] +=== `++IERC3156FlashBorrower++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC3156FlashBorrower.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -979,9 +1089,26 @@ Receive a flash loan. :previewRedeem: pass:normal[xref:#IERC4626-previewRedeem-uint256-[`++previewRedeem++`]] :redeem: pass:normal[xref:#IERC4626-redeem-uint256-address-address-[`++redeem++`]] +:asset-: pass:normal[xref:#IERC4626-asset--[`++asset++`]] +:totalAssets-: pass:normal[xref:#IERC4626-totalAssets--[`++totalAssets++`]] +:convertToShares-uint256: pass:normal[xref:#IERC4626-convertToShares-uint256-[`++convertToShares++`]] +:convertToAssets-uint256: pass:normal[xref:#IERC4626-convertToAssets-uint256-[`++convertToAssets++`]] +:maxDeposit-address: pass:normal[xref:#IERC4626-maxDeposit-address-[`++maxDeposit++`]] +:previewDeposit-uint256: pass:normal[xref:#IERC4626-previewDeposit-uint256-[`++previewDeposit++`]] +:deposit-uint256-address: pass:normal[xref:#IERC4626-deposit-uint256-address-[`++deposit++`]] +:maxMint-address: pass:normal[xref:#IERC4626-maxMint-address-[`++maxMint++`]] +:previewMint-uint256: pass:normal[xref:#IERC4626-previewMint-uint256-[`++previewMint++`]] +:mint-uint256-address: pass:normal[xref:#IERC4626-mint-uint256-address-[`++mint++`]] +:maxWithdraw-address: pass:normal[xref:#IERC4626-maxWithdraw-address-[`++maxWithdraw++`]] +:previewWithdraw-uint256: pass:normal[xref:#IERC4626-previewWithdraw-uint256-[`++previewWithdraw++`]] +:withdraw-uint256-address-address: pass:normal[xref:#IERC4626-withdraw-uint256-address-address-[`++withdraw++`]] +:maxRedeem-address: pass:normal[xref:#IERC4626-maxRedeem-address-[`++maxRedeem++`]] +:previewRedeem-uint256: pass:normal[xref:#IERC4626-previewRedeem-uint256-[`++previewRedeem++`]] +:redeem-uint256-address-address: pass:normal[xref:#IERC4626-redeem-uint256-address-address-[`++redeem++`]] + [.contract] [[IERC4626]] -=== `++IERC4626++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC4626.sol[{github-icon},role=heading-link] +=== `++IERC4626++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC4626.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1238,7 +1365,7 @@ through a redeem call. [[IERC4626-previewRedeem-uint256-]] ==== `[.contract-item-name]#++previewRedeem++#++(uint256 shares) → uint256 assets++` [.item-kind]#external# -Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block, +Allows an on-chain or off-chain user to simulate the effects of their redemption at the current block, given current on-chain conditions. - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call @@ -1275,40 +1402,81 @@ Those methods should be performed separately. [[IERC4626-Withdraw-address-address-address-uint256-uint256-]] ==== `[.contract-item-name]#++Withdraw++#++(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares)++` [.item-kind]#event# -:owner: pass:normal[xref:#IERC5313-owner--[`++owner++`]] +:MetadataUpdate: pass:normal[xref:#IERC4906-MetadataUpdate-uint256-[`++MetadataUpdate++`]] +:BatchMetadataUpdate: pass:normal[xref:#IERC4906-BatchMetadataUpdate-uint256-uint256-[`++BatchMetadataUpdate++`]] [.contract] -[[IERC5313]] -=== `++IERC5313++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC5313.sol[{github-icon},role=heading-link] +[[IERC4906]] +=== `++IERC4906++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC4906.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity -import "@openzeppelin/contracts/interfaces/IERC5313.sol"; +import "@openzeppelin/contracts/interfaces/IERC4906.sol"; ``` -Interface for the Light Contract Ownership Standard. - -A standardized minimal interface required to identify an account that controls a contract - [.contract-index] .Functions -- -* {xref-IERC5313-owner--}[`++owner()++`] + +[.contract-subindex-inherited] +.IERC721 +* {xref-IERC721-balanceOf-address-}[`++balanceOf(owner)++`] +* {xref-IERC721-ownerOf-uint256-}[`++ownerOf(tokenId)++`] +* {xref-IERC721-safeTransferFrom-address-address-uint256-bytes-}[`++safeTransferFrom(from, to, tokenId, data)++`] +* {xref-IERC721-safeTransferFrom-address-address-uint256-}[`++safeTransferFrom(from, to, tokenId)++`] +* {xref-IERC721-transferFrom-address-address-uint256-}[`++transferFrom(from, to, tokenId)++`] +* {xref-IERC721-approve-address-uint256-}[`++approve(to, tokenId)++`] +* {xref-IERC721-setApprovalForAll-address-bool-}[`++setApprovalForAll(operator, approved)++`] +* {xref-IERC721-getApproved-uint256-}[`++getApproved(tokenId)++`] +* {xref-IERC721-isApprovedForAll-address-address-}[`++isApprovedForAll(owner, operator)++`] + +[.contract-subindex-inherited] +.IERC165 +* {xref-IERC165-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] + +-- + +[.contract-index] +.Events +-- +* {xref-IERC4906-MetadataUpdate-uint256-}[`++MetadataUpdate(_tokenId)++`] +* {xref-IERC4906-BatchMetadataUpdate-uint256-uint256-}[`++BatchMetadataUpdate(_fromTokenId, _toTokenId)++`] + +[.contract-subindex-inherited] +.IERC721 +* {xref-IERC721-Transfer-address-address-uint256-}[`++Transfer(from, to, tokenId)++`] +* {xref-IERC721-Approval-address-address-uint256-}[`++Approval(owner, approved, tokenId)++`] +* {xref-IERC721-ApprovalForAll-address-address-bool-}[`++ApprovalForAll(owner, operator, approved)++`] + +[.contract-subindex-inherited] +.IERC165 -- [.contract-item] -[[IERC5313-owner--]] -==== `[.contract-item-name]#++owner++#++() → address++` [.item-kind]#external# +[[IERC4906-MetadataUpdate-uint256-]] +==== `[.contract-item-name]#++MetadataUpdate++#++(uint256 _tokenId)++` [.item-kind]#event# -Gets the address of the owner. +This event emits when the metadata of a token is changed. +So that the third-party platforms such as NFT market could +timely update the images and related attributes of the NFT. + +[.contract-item] +[[IERC4906-BatchMetadataUpdate-uint256-uint256-]] +==== `[.contract-item-name]#++BatchMetadataUpdate++#++(uint256 _fromTokenId, uint256 _toTokenId)++` [.item-kind]#event# + +This event emits when the metadata of a range of tokens is changed. +So that the third-party platforms such as NFT market could +timely update the images and related attributes of the NFTs. :EIP712DomainChanged: pass:normal[xref:#IERC5267-EIP712DomainChanged--[`++EIP712DomainChanged++`]] :eip712Domain: pass:normal[xref:#IERC5267-eip712Domain--[`++eip712Domain++`]] +:eip712Domain-: pass:normal[xref:#IERC5267-eip712Domain--[`++eip712Domain++`]] + [.contract] [[IERC5267]] -=== `++IERC5267++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC5267.sol[{github-icon},role=heading-link] +=== `++IERC5267++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC5267.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1342,9 +1510,39 @@ signature. MAY be emitted to signal that the domain could have changed. +:owner: pass:normal[xref:#IERC5313-owner--[`++owner++`]] + +:owner-: pass:normal[xref:#IERC5313-owner--[`++owner++`]] + +[.contract] +[[IERC5313]] +=== `++IERC5313++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC5313.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/interfaces/IERC5313.sol"; +``` + +Interface for the Light Contract Ownership Standard. + +A standardized minimal interface required to identify an account that controls a contract + +[.contract-index] +.Functions +-- +* {xref-IERC5313-owner--}[`++owner()++`] + +-- + +[.contract-item] +[[IERC5313-owner--]] +==== `[.contract-item-name]#++owner++#++() → address++` [.item-kind]#external# + +Gets the address of the owner. + [.contract] [[IERC5805]] -=== `++IERC5805++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC5805.sol[{github-icon},role=heading-link] +=== `++IERC5805++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC5805.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1401,9 +1599,12 @@ import "@openzeppelin/contracts/interfaces/IERC5805.sol"; :clock: pass:normal[xref:#IERC6372-clock--[`++clock++`]] :CLOCK_MODE: pass:normal[xref:#IERC6372-CLOCK_MODE--[`++CLOCK_MODE++`]] +:clock-: pass:normal[xref:#IERC6372-clock--[`++clock++`]] +:CLOCK_MODE-: pass:normal[xref:#IERC6372-CLOCK_MODE--[`++CLOCK_MODE++`]] + [.contract] [[IERC6372]] -=== `++IERC6372++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/IERC6372.sol[{github-icon},role=heading-link] +=== `++IERC6372++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/IERC6372.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1430,11 +1631,343 @@ Clock used for flagging checkpoints. Can be overridden to implement timestamp ba Description of the clock +:Approval: pass:normal[xref:#IERC6909-Approval-address-address-uint256-uint256-[`++Approval++`]] +:OperatorSet: pass:normal[xref:#IERC6909-OperatorSet-address-address-bool-[`++OperatorSet++`]] +:Transfer: pass:normal[xref:#IERC6909-Transfer-address-address-address-uint256-uint256-[`++Transfer++`]] +:balanceOf: pass:normal[xref:#IERC6909-balanceOf-address-uint256-[`++balanceOf++`]] +:allowance: pass:normal[xref:#IERC6909-allowance-address-address-uint256-[`++allowance++`]] +:isOperator: pass:normal[xref:#IERC6909-isOperator-address-address-[`++isOperator++`]] +:approve: pass:normal[xref:#IERC6909-approve-address-uint256-uint256-[`++approve++`]] +:setOperator: pass:normal[xref:#IERC6909-setOperator-address-bool-[`++setOperator++`]] +:transfer: pass:normal[xref:#IERC6909-transfer-address-uint256-uint256-[`++transfer++`]] +:transferFrom: pass:normal[xref:#IERC6909-transferFrom-address-address-uint256-uint256-[`++transferFrom++`]] + +:balanceOf-address-uint256: pass:normal[xref:#IERC6909-balanceOf-address-uint256-[`++balanceOf++`]] +:allowance-address-address-uint256: pass:normal[xref:#IERC6909-allowance-address-address-uint256-[`++allowance++`]] +:isOperator-address-address: pass:normal[xref:#IERC6909-isOperator-address-address-[`++isOperator++`]] +:approve-address-uint256-uint256: pass:normal[xref:#IERC6909-approve-address-uint256-uint256-[`++approve++`]] +:setOperator-address-bool: pass:normal[xref:#IERC6909-setOperator-address-bool-[`++setOperator++`]] +:transfer-address-uint256-uint256: pass:normal[xref:#IERC6909-transfer-address-uint256-uint256-[`++transfer++`]] +:transferFrom-address-address-uint256-uint256: pass:normal[xref:#IERC6909-transferFrom-address-address-uint256-uint256-[`++transferFrom++`]] + +[.contract] +[[IERC6909]] +=== `++IERC6909++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6909.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/interfaces/draft-IERC6909.sol"; +``` + +Required interface of an ERC-6909 compliant contract, as defined in the +https://eips.ethereum.org/EIPS/eip-6909[ERC]. + +[.contract-index] +.Functions +-- +* {xref-IERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-IERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-IERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-IERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-IERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-IERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-IERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 +* {xref-IERC165-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] + +-- + +[.contract-index] +.Events +-- +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[IERC6909-balanceOf-address-uint256-]] +==== `[.contract-item-name]#++balanceOf++#++(address owner, uint256 id) → uint256++` [.item-kind]#external# + +Returns the amount of tokens of type `id` owned by `owner`. + +[.contract-item] +[[IERC6909-allowance-address-address-uint256-]] +==== `[.contract-item-name]#++allowance++#++(address owner, address spender, uint256 id) → uint256++` [.item-kind]#external# + +Returns the amount of tokens of type `id` that `spender` is allowed to spend on behalf of `owner`. + +NOTE: Does not include operator allowances. + +[.contract-item] +[[IERC6909-isOperator-address-address-]] +==== `[.contract-item-name]#++isOperator++#++(address owner, address spender) → bool++` [.item-kind]#external# + +Returns true if `spender` is set as an operator for `owner`. + +[.contract-item] +[[IERC6909-approve-address-uint256-uint256-]] +==== `[.contract-item-name]#++approve++#++(address spender, uint256 id, uint256 amount) → bool++` [.item-kind]#external# + +Sets an approval to `spender` for `amount` of tokens of type `id` from the caller's tokens. An `amount` of +`type(uint256).max` signifies an unlimited approval. + +Must return true. + +[.contract-item] +[[IERC6909-setOperator-address-bool-]] +==== `[.contract-item-name]#++setOperator++#++(address spender, bool approved) → bool++` [.item-kind]#external# + +Grants or revokes unlimited transfer permission of any token id to `spender` for the caller's tokens. + +Must return true. + +[.contract-item] +[[IERC6909-transfer-address-uint256-uint256-]] +==== `[.contract-item-name]#++transfer++#++(address receiver, uint256 id, uint256 amount) → bool++` [.item-kind]#external# + +Transfers `amount` of token type `id` from the caller's account to `receiver`. + +Must return true. + +[.contract-item] +[[IERC6909-transferFrom-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++transferFrom++#++(address sender, address receiver, uint256 id, uint256 amount) → bool++` [.item-kind]#external# + +Transfers `amount` of token type `id` from `sender` to `receiver`. + +Must return true. + +[.contract-item] +[[IERC6909-Approval-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++Approval++#++(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount)++` [.item-kind]#event# + +Emitted when the allowance of a `spender` for an `owner` is set for a token of type `id`. +The new allowance is `amount`. + +[.contract-item] +[[IERC6909-OperatorSet-address-address-bool-]] +==== `[.contract-item-name]#++OperatorSet++#++(address indexed owner, address indexed spender, bool approved)++` [.item-kind]#event# + +Emitted when `owner` grants or revokes operator status for a `spender`. + +[.contract-item] +[[IERC6909-Transfer-address-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++Transfer++#++(address caller, address indexed sender, address indexed receiver, uint256 indexed id, uint256 amount)++` [.item-kind]#event# + +Emitted when `amount` tokens of type `id` are moved from `sender` to `receiver` initiated by `caller`. + +:contractURI: pass:normal[xref:#IERC6909ContentURI-contractURI--[`++contractURI++`]] +:tokenURI: pass:normal[xref:#IERC6909ContentURI-tokenURI-uint256-[`++tokenURI++`]] + +:contractURI-: pass:normal[xref:#IERC6909ContentURI-contractURI--[`++contractURI++`]] +:tokenURI-uint256: pass:normal[xref:#IERC6909ContentURI-tokenURI-uint256-[`++tokenURI++`]] + +[.contract] +[[IERC6909ContentURI]] +=== `++IERC6909ContentURI++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6909.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/interfaces/draft-IERC6909.sol"; +``` + +Optional extension of {IERC6909} that adds content URI functions. + +[.contract-index] +.Functions +-- +* {xref-IERC6909ContentURI-contractURI--}[`++contractURI()++`] +* {xref-IERC6909ContentURI-tokenURI-uint256-}[`++tokenURI(id)++`] + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-IERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-IERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-IERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-IERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-IERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-IERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 +* {xref-IERC165-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] + +-- + +[.contract-index] +.Events +-- + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[IERC6909ContentURI-contractURI--]] +==== `[.contract-item-name]#++contractURI++#++() → string++` [.item-kind]#external# + +Returns URI for the contract. + +[.contract-item] +[[IERC6909ContentURI-tokenURI-uint256-]] +==== `[.contract-item-name]#++tokenURI++#++(uint256 id) → string++` [.item-kind]#external# + +Returns the URI for the token of type `id`. + +:name: pass:normal[xref:#IERC6909Metadata-name-uint256-[`++name++`]] +:symbol: pass:normal[xref:#IERC6909Metadata-symbol-uint256-[`++symbol++`]] +:decimals: pass:normal[xref:#IERC6909Metadata-decimals-uint256-[`++decimals++`]] + +:name-uint256: pass:normal[xref:#IERC6909Metadata-name-uint256-[`++name++`]] +:symbol-uint256: pass:normal[xref:#IERC6909Metadata-symbol-uint256-[`++symbol++`]] +:decimals-uint256: pass:normal[xref:#IERC6909Metadata-decimals-uint256-[`++decimals++`]] + +[.contract] +[[IERC6909Metadata]] +=== `++IERC6909Metadata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6909.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/interfaces/draft-IERC6909.sol"; +``` + +Optional extension of {IERC6909} that adds metadata functions. + +[.contract-index] +.Functions +-- +* {xref-IERC6909Metadata-name-uint256-}[`++name(id)++`] +* {xref-IERC6909Metadata-symbol-uint256-}[`++symbol(id)++`] +* {xref-IERC6909Metadata-decimals-uint256-}[`++decimals(id)++`] + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-IERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-IERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-IERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-IERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-IERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-IERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 +* {xref-IERC165-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] + +-- + +[.contract-index] +.Events +-- + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[IERC6909Metadata-name-uint256-]] +==== `[.contract-item-name]#++name++#++(uint256 id) → string++` [.item-kind]#external# + +Returns the name of the token of type `id`. + +[.contract-item] +[[IERC6909Metadata-symbol-uint256-]] +==== `[.contract-item-name]#++symbol++#++(uint256 id) → string++` [.item-kind]#external# + +Returns the ticker symbol of the token of type `id`. + +[.contract-item] +[[IERC6909Metadata-decimals-uint256-]] +==== `[.contract-item-name]#++decimals++#++(uint256 id) → uint8++` [.item-kind]#external# + +Returns the number of decimals for the token of type `id`. + +:totalSupply: pass:normal[xref:#IERC6909TokenSupply-totalSupply-uint256-[`++totalSupply++`]] + +:totalSupply-uint256: pass:normal[xref:#IERC6909TokenSupply-totalSupply-uint256-[`++totalSupply++`]] + +[.contract] +[[IERC6909TokenSupply]] +=== `++IERC6909TokenSupply++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC6909.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/interfaces/draft-IERC6909.sol"; +``` + +Optional extension of {IERC6909} that adds a token supply function. + +[.contract-index] +.Functions +-- +* {xref-IERC6909TokenSupply-totalSupply-uint256-}[`++totalSupply(id)++`] + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-IERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-IERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-IERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-IERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-IERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-IERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 +* {xref-IERC165-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] + +-- + +[.contract-index] +.Events +-- + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[IERC6909TokenSupply-totalSupply-uint256-]] +==== `[.contract-item-name]#++totalSupply++#++(uint256 id) → uint256++` [.item-kind]#external# + +Returns the total supply of the token of type `id`. + :temporaryApprove: pass:normal[xref:#IERC7674-temporaryApprove-address-uint256-[`++temporaryApprove++`]] +:temporaryApprove-address-uint256: pass:normal[xref:#IERC7674-temporaryApprove-address-uint256-[`++temporaryApprove++`]] + [.contract] [[IERC7674]] -=== `++IERC7674++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/interfaces/draft-IERC7674.sol[{github-icon},role=heading-link] +=== `++IERC7674++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/interfaces/draft-IERC7674.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity diff --git a/docs/modules/api/pages/metatx.adoc b/docs/modules/api/pages/metatx.adoc index fa8310d65..a2ac30d3f 100644 --- a/docs/modules/api/pages/metatx.adoc +++ b/docs/modules/api/pages/metatx.adoc @@ -15,6 +15,7 @@ :xref-ERC2771Forwarder-_validate-struct-ERC2771Forwarder-ForwardRequestData-: xref:metatx.adoc#ERC2771Forwarder-_validate-struct-ERC2771Forwarder-ForwardRequestData- :xref-ERC2771Forwarder-_recoverForwardRequestSigner-struct-ERC2771Forwarder-ForwardRequestData-: xref:metatx.adoc#ERC2771Forwarder-_recoverForwardRequestSigner-struct-ERC2771Forwarder-ForwardRequestData- :xref-ERC2771Forwarder-_execute-struct-ERC2771Forwarder-ForwardRequestData-bool-: xref:metatx.adoc#ERC2771Forwarder-_execute-struct-ERC2771Forwarder-ForwardRequestData-bool- +:xref-ERC2771Forwarder-_isTrustedByTarget-address-: xref:metatx.adoc#ERC2771Forwarder-_isTrustedByTarget-address- :xref-Nonces-nonces-address-: xref:utils.adoc#Nonces-nonces-address- :xref-Nonces-_useNonce-address-: xref:utils.adoc#Nonces-_useNonce-address- :xref-Nonces-_useCheckedNonce-address-uint256-: xref:utils.adoc#Nonces-_useCheckedNonce-address-uint256- @@ -33,6 +34,7 @@ :xref-ERC2771Forwarder-_FORWARD_REQUEST_TYPEHASH-bytes32: xref:metatx.adoc#ERC2771Forwarder-_FORWARD_REQUEST_TYPEHASH-bytes32 :EIP712-constructor: pass:normal[xref:utils.adoc#EIP712-constructor-string-string-[`EIP712.constructor`]] :ECDSA-tryRecover: pass:normal[xref:utils.adoc#ECDSA-tryRecover-bytes32-uint8-bytes32-bytes32-[`ECDSA.tryRecover`]] +:ERC2771Context-isTrustedForwarder: pass:normal[xref:metatx.adoc#ERC2771Context-isTrustedForwarder-address-[`ERC2771Context.isTrustedForwarder`]] = Meta Transactions [.readme-notice] @@ -52,9 +54,16 @@ This directory includes contracts for adding meta-transaction capabilities (i.e. :_msgData: pass:normal[xref:#ERC2771Context-_msgData--[`++_msgData++`]] :_contextSuffixLength: pass:normal[xref:#ERC2771Context-_contextSuffixLength--[`++_contextSuffixLength++`]] +:constructor-address: pass:normal[xref:#ERC2771Context-constructor-address-[`++constructor++`]] +:trustedForwarder-: pass:normal[xref:#ERC2771Context-trustedForwarder--[`++trustedForwarder++`]] +:isTrustedForwarder-address: pass:normal[xref:#ERC2771Context-isTrustedForwarder-address-[`++isTrustedForwarder++`]] +:_msgSender-: pass:normal[xref:#ERC2771Context-_msgSender--[`++_msgSender++`]] +:_msgData-: pass:normal[xref:#ERC2771Context-_msgData--[`++_msgData++`]] +:_contextSuffixLength-: pass:normal[xref:#ERC2771Context-_contextSuffixLength--[`++_contextSuffixLength++`]] + [.contract] [[ERC2771Context]] -=== `++ERC2771Context++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/metatx/ERC2771Context.sol[{github-icon},role=heading-link] +=== `++ERC2771Context++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/metatx/ERC2771Context.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -139,10 +148,20 @@ ERC-2771 specifies the context as being a single address (20 bytes). :_validate: pass:normal[xref:#ERC2771Forwarder-_validate-struct-ERC2771Forwarder-ForwardRequestData-[`++_validate++`]] :_recoverForwardRequestSigner: pass:normal[xref:#ERC2771Forwarder-_recoverForwardRequestSigner-struct-ERC2771Forwarder-ForwardRequestData-[`++_recoverForwardRequestSigner++`]] :_execute: pass:normal[xref:#ERC2771Forwarder-_execute-struct-ERC2771Forwarder-ForwardRequestData-bool-[`++_execute++`]] +:_isTrustedByTarget: pass:normal[xref:#ERC2771Forwarder-_isTrustedByTarget-address-[`++_isTrustedByTarget++`]] + +:constructor-string: pass:normal[xref:#ERC2771Forwarder-constructor-string-[`++constructor++`]] +:verify-struct-ERC2771Forwarder-ForwardRequestData: pass:normal[xref:#ERC2771Forwarder-verify-struct-ERC2771Forwarder-ForwardRequestData-[`++verify++`]] +:execute-struct-ERC2771Forwarder-ForwardRequestData: pass:normal[xref:#ERC2771Forwarder-execute-struct-ERC2771Forwarder-ForwardRequestData-[`++execute++`]] +:executeBatch-struct-ERC2771Forwarder-ForwardRequestData---address-payable: pass:normal[xref:#ERC2771Forwarder-executeBatch-struct-ERC2771Forwarder-ForwardRequestData---address-payable-[`++executeBatch++`]] +:_validate-struct-ERC2771Forwarder-ForwardRequestData: pass:normal[xref:#ERC2771Forwarder-_validate-struct-ERC2771Forwarder-ForwardRequestData-[`++_validate++`]] +:_recoverForwardRequestSigner-struct-ERC2771Forwarder-ForwardRequestData: pass:normal[xref:#ERC2771Forwarder-_recoverForwardRequestSigner-struct-ERC2771Forwarder-ForwardRequestData-[`++_recoverForwardRequestSigner++`]] +:_execute-struct-ERC2771Forwarder-ForwardRequestData-bool: pass:normal[xref:#ERC2771Forwarder-_execute-struct-ERC2771Forwarder-ForwardRequestData-bool-[`++_execute++`]] +:_isTrustedByTarget-address: pass:normal[xref:#ERC2771Forwarder-_isTrustedByTarget-address-[`++_isTrustedByTarget++`]] [.contract] [[ERC2771Forwarder]] -=== `++ERC2771Forwarder++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/metatx/ERC2771Forwarder.sol[{github-icon},role=heading-link] +=== `++ERC2771Forwarder++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/metatx/ERC2771Forwarder.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -196,6 +215,7 @@ used to execute arbitrary code. * {xref-ERC2771Forwarder-_validate-struct-ERC2771Forwarder-ForwardRequestData-}[`++_validate(request)++`] * {xref-ERC2771Forwarder-_recoverForwardRequestSigner-struct-ERC2771Forwarder-ForwardRequestData-}[`++_recoverForwardRequestSigner(request)++`] * {xref-ERC2771Forwarder-_execute-struct-ERC2771Forwarder-ForwardRequestData-bool-}[`++_execute(request, requireValidRequest)++`] +* {xref-ERC2771Forwarder-_isTrustedByTarget-address-}[`++_isTrustedByTarget(target)++`] [.contract-subindex-inherited] .Nonces @@ -360,6 +380,18 @@ Emits an {ExecutedForwardRequest} event. IMPORTANT: Using this function doesn't check that all the `msg.value` was sent, potentially leaving value stuck in the contract. +[.contract-item] +[[ERC2771Forwarder-_isTrustedByTarget-address-]] +==== `[.contract-item-name]#++_isTrustedByTarget++#++(address target) → bool++` [.item-kind]#internal# + +Returns whether the target trusts this forwarder. + +This function performs a static call to the target contract calling the +{ERC2771Context-isTrustedForwarder} function. + +NOTE: Consider the execution of this forwarder is permissionless. Without this check, anyone may transfer assets +that are owned by, or are approved to this forwarder. + [.contract-item] [[ERC2771Forwarder-ExecutedForwardRequest-address-uint256-bool-]] ==== `[.contract-item-name]#++ExecutedForwardRequest++#++(address indexed signer, uint256 nonce, bool success)++` [.item-kind]#event# diff --git a/docs/modules/api/pages/proxy.adoc b/docs/modules/api/pages/proxy.adoc index 57cf4bd7a..5413b4916 100644 --- a/docs/modules/api/pages/proxy.adoc +++ b/docs/modules/api/pages/proxy.adoc @@ -124,6 +124,7 @@ :xref-Initializable-_disableInitializers--: xref:proxy.adoc#Initializable-_disableInitializers-- :xref-Initializable-_getInitializedVersion--: xref:proxy.adoc#Initializable-_getInitializedVersion-- :xref-Initializable-_isInitializing--: xref:proxy.adoc#Initializable-_isInitializing-- +:xref-Initializable-_initializableStorageSlot--: xref:proxy.adoc#Initializable-_initializableStorageSlot-- :xref-Initializable-Initialized-uint64-: xref:proxy.adoc#Initializable-Initialized-uint64- :xref-Initializable-InvalidInitialization--: xref:proxy.adoc#Initializable-InvalidInitialization-- :xref-Initializable-NotInitializing--: xref:proxy.adoc#Initializable-NotInitializing-- @@ -198,9 +199,14 @@ The current implementation of this security mechanism uses https://eips.ethereum :_fallback: pass:normal[xref:#Proxy-_fallback--[`++_fallback++`]] :fallback: pass:normal[xref:#Proxy-fallback--[`++fallback++`]] +:_delegate-address: pass:normal[xref:#Proxy-_delegate-address-[`++_delegate++`]] +:_implementation-: pass:normal[xref:#Proxy-_implementation--[`++_implementation++`]] +:_fallback-: pass:normal[xref:#Proxy-_fallback--[`++_fallback++`]] +:fallback-: pass:normal[xref:#Proxy-fallback--[`++fallback++`]] + [.contract] [[Proxy]] -=== `++Proxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/Proxy.sol[{github-icon},role=heading-link] +=== `++Proxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/Proxy.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -261,9 +267,12 @@ function in the contract matches the call data. :constructor: pass:normal[xref:#ERC1967Proxy-constructor-address-bytes-[`++constructor++`]] :_implementation: pass:normal[xref:#ERC1967Proxy-_implementation--[`++_implementation++`]] +:constructor-address-bytes: pass:normal[xref:#ERC1967Proxy-constructor-address-bytes-[`++constructor++`]] +:_implementation-: pass:normal[xref:#ERC1967Proxy-_implementation--[`++_implementation++`]] + [.contract] [[ERC1967Proxy]] -=== `++ERC1967Proxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/ERC1967/ERC1967Proxy.sol[{github-icon},role=heading-link] +=== `++ERC1967Proxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/ERC1967/ERC1967Proxy.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -326,9 +335,16 @@ the https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call. :getBeacon: pass:normal[xref:#ERC1967Utils-getBeacon--[`++getBeacon++`]] :upgradeBeaconToAndCall: pass:normal[xref:#ERC1967Utils-upgradeBeaconToAndCall-address-bytes-[`++upgradeBeaconToAndCall++`]] +:getImplementation-: pass:normal[xref:#ERC1967Utils-getImplementation--[`++getImplementation++`]] +:upgradeToAndCall-address-bytes: pass:normal[xref:#ERC1967Utils-upgradeToAndCall-address-bytes-[`++upgradeToAndCall++`]] +:getAdmin-: pass:normal[xref:#ERC1967Utils-getAdmin--[`++getAdmin++`]] +:changeAdmin-address: pass:normal[xref:#ERC1967Utils-changeAdmin-address-[`++changeAdmin++`]] +:getBeacon-: pass:normal[xref:#ERC1967Utils-getBeacon--[`++getBeacon++`]] +:upgradeBeaconToAndCall-address-bytes: pass:normal[xref:#ERC1967Utils-upgradeBeaconToAndCall-address-bytes-[`++upgradeBeaconToAndCall++`]] + [.contract] [[ERC1967Utils]] -=== `++ERC1967Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/ERC1967/ERC1967Utils.sol[{github-icon},role=heading-link] +=== `++ERC1967Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/ERC1967/ERC1967Utils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -475,9 +491,13 @@ This is the keccak-256 hash of "eip1967.proxy.beacon" subtracted by 1. :_proxyAdmin: pass:normal[xref:#TransparentUpgradeableProxy-_proxyAdmin--[`++_proxyAdmin++`]] :_fallback: pass:normal[xref:#TransparentUpgradeableProxy-_fallback--[`++_fallback++`]] +:constructor-address-address-bytes: pass:normal[xref:#TransparentUpgradeableProxy-constructor-address-address-bytes-[`++constructor++`]] +:_proxyAdmin-: pass:normal[xref:#TransparentUpgradeableProxy-_proxyAdmin--[`++_proxyAdmin++`]] +:_fallback-: pass:normal[xref:#TransparentUpgradeableProxy-_fallback--[`++_fallback++`]] + [.contract] [[TransparentUpgradeableProxy]] -=== `++TransparentUpgradeableProxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/transparent/TransparentUpgradeableProxy.sol[{github-icon},role=heading-link] +=== `++TransparentUpgradeableProxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/transparent/TransparentUpgradeableProxy.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -584,9 +604,13 @@ The proxy caller is the current admin, and can't fallback to the proxy target. :constructor: pass:normal[xref:#ProxyAdmin-constructor-address-[`++constructor++`]] :upgradeAndCall: pass:normal[xref:#ProxyAdmin-upgradeAndCall-contract-ITransparentUpgradeableProxy-address-bytes-[`++upgradeAndCall++`]] +:constructor-address: pass:normal[xref:#ProxyAdmin-constructor-address-[`++constructor++`]] +:upgradeAndCall-contract-ITransparentUpgradeableProxy-address-bytes: pass:normal[xref:#ProxyAdmin-upgradeAndCall-contract-ITransparentUpgradeableProxy-address-bytes-[`++upgradeAndCall++`]] +:UPGRADE_INTERFACE_VERSION-string: pass:normal[xref:#ProxyAdmin-UPGRADE_INTERFACE_VERSION-string[`++UPGRADE_INTERFACE_VERSION++`]] + [.contract] [[ProxyAdmin]] -=== `++ProxyAdmin++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/transparent/ProxyAdmin.sol[{github-icon},role=heading-link] +=== `++ProxyAdmin++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/transparent/ProxyAdmin.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -669,9 +693,13 @@ during an upgrade. :_implementation: pass:normal[xref:#BeaconProxy-_implementation--[`++_implementation++`]] :_getBeacon: pass:normal[xref:#BeaconProxy-_getBeacon--[`++_getBeacon++`]] +:constructor-address-bytes: pass:normal[xref:#BeaconProxy-constructor-address-bytes-[`++constructor++`]] +:_implementation-: pass:normal[xref:#BeaconProxy-_implementation--[`++_implementation++`]] +:_getBeacon-: pass:normal[xref:#BeaconProxy-_getBeacon--[`++_getBeacon++`]] + [.contract] [[BeaconProxy]] -=== `++BeaconProxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/beacon/BeaconProxy.sol[{github-icon},role=heading-link] +=== `++BeaconProxy++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/beacon/BeaconProxy.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -734,9 +762,11 @@ Returns the beacon. :implementation: pass:normal[xref:#IBeacon-implementation--[`++implementation++`]] +:implementation-: pass:normal[xref:#IBeacon-implementation--[`++implementation++`]] + [.contract] [[IBeacon]] -=== `++IBeacon++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/beacon/IBeacon.sol[{github-icon},role=heading-link] +=== `++IBeacon++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/beacon/IBeacon.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -766,9 +796,13 @@ Must return an address that can be used as a delegate call target. :implementation: pass:normal[xref:#UpgradeableBeacon-implementation--[`++implementation++`]] :upgradeTo: pass:normal[xref:#UpgradeableBeacon-upgradeTo-address-[`++upgradeTo++`]] +:constructor-address-address: pass:normal[xref:#UpgradeableBeacon-constructor-address-address-[`++constructor++`]] +:implementation-: pass:normal[xref:#UpgradeableBeacon-implementation--[`++implementation++`]] +:upgradeTo-address: pass:normal[xref:#UpgradeableBeacon-upgradeTo-address-[`++upgradeTo++`]] + [.contract] [[UpgradeableBeacon]] -=== `++UpgradeableBeacon++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/beacon/UpgradeableBeacon.sol[{github-icon},role=heading-link] +=== `++UpgradeableBeacon++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/beacon/UpgradeableBeacon.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -883,9 +917,23 @@ The `implementation` of the beacon is invalid. :predictDeterministicAddressWithImmutableArgs: pass:normal[xref:#Clones-predictDeterministicAddressWithImmutableArgs-address-bytes-bytes32-[`++predictDeterministicAddressWithImmutableArgs++`]] :fetchCloneArgs: pass:normal[xref:#Clones-fetchCloneArgs-address-[`++fetchCloneArgs++`]] +:clone-address: pass:normal[xref:#Clones-clone-address-[`++clone++`]] +:clone-address-uint256: pass:normal[xref:#Clones-clone-address-uint256-[`++clone++`]] +:cloneDeterministic-address-bytes32: pass:normal[xref:#Clones-cloneDeterministic-address-bytes32-[`++cloneDeterministic++`]] +:cloneDeterministic-address-bytes32-uint256: pass:normal[xref:#Clones-cloneDeterministic-address-bytes32-uint256-[`++cloneDeterministic++`]] +:predictDeterministicAddress-address-bytes32-address: pass:normal[xref:#Clones-predictDeterministicAddress-address-bytes32-address-[`++predictDeterministicAddress++`]] +:predictDeterministicAddress-address-bytes32: pass:normal[xref:#Clones-predictDeterministicAddress-address-bytes32-[`++predictDeterministicAddress++`]] +:cloneWithImmutableArgs-address-bytes: pass:normal[xref:#Clones-cloneWithImmutableArgs-address-bytes-[`++cloneWithImmutableArgs++`]] +:cloneWithImmutableArgs-address-bytes-uint256: pass:normal[xref:#Clones-cloneWithImmutableArgs-address-bytes-uint256-[`++cloneWithImmutableArgs++`]] +:cloneDeterministicWithImmutableArgs-address-bytes-bytes32: pass:normal[xref:#Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-[`++cloneDeterministicWithImmutableArgs++`]] +:cloneDeterministicWithImmutableArgs-address-bytes-bytes32-uint256: pass:normal[xref:#Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-uint256-[`++cloneDeterministicWithImmutableArgs++`]] +:predictDeterministicAddressWithImmutableArgs-address-bytes-bytes32-address: pass:normal[xref:#Clones-predictDeterministicAddressWithImmutableArgs-address-bytes-bytes32-address-[`++predictDeterministicAddressWithImmutableArgs++`]] +:predictDeterministicAddressWithImmutableArgs-address-bytes-bytes32: pass:normal[xref:#Clones-predictDeterministicAddressWithImmutableArgs-address-bytes-bytes32-[`++predictDeterministicAddressWithImmutableArgs++`]] +:fetchCloneArgs-address: pass:normal[xref:#Clones-fetchCloneArgs-address-[`++fetchCloneArgs++`]] + [.contract] [[Clones]] -=== `++Clones++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/Clones.sol[{github-icon},role=heading-link] +=== `++Clones++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/Clones.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -932,7 +980,7 @@ deterministic method. [[Clones-clone-address-]] ==== `[.contract-item-name]#++clone++#++(address implementation) → address instance++` [.item-kind]#internal# -Deploys and returns the address of a clone that mimics the behaviour of `implementation`. +Deploys and returns the address of a clone that mimics the behavior of `implementation`. This function uses the create opcode, which should never revert. @@ -950,7 +998,7 @@ to always have enough balance for new deployments. Consider exposing this functi [[Clones-cloneDeterministic-address-bytes32-]] ==== `[.contract-item-name]#++cloneDeterministic++#++(address implementation, bytes32 salt) → address instance++` [.item-kind]#internal# -Deploys and returns the address of a clone that mimics the behaviour of `implementation`. +Deploys and returns the address of a clone that mimics the behavior of `implementation`. This function uses the create2 opcode and a `salt` to deterministically deploy the clone. Using the same `implementation` and `salt` multiple times will revert, since @@ -1002,7 +1050,7 @@ to always have enough balance for new deployments. Consider exposing this functi [[Clones-cloneDeterministicWithImmutableArgs-address-bytes-bytes32-]] ==== `[.contract-item-name]#++cloneDeterministicWithImmutableArgs++#++(address implementation, bytes args, bytes32 salt) → address instance++` [.item-kind]#internal# -Deploys and returns the address of a clone that mimics the behaviour of `implementation` with custom +Deploys and returns the address of a clone that mimics the behavior of `implementation` with custom immutable arguments. These are provided through `args` and cannot be changed after deployment. To access the arguments within the implementation, use {fetchCloneArgs}. @@ -1063,10 +1111,17 @@ Get the immutable args attached to a clone. :_disableInitializers: pass:normal[xref:#Initializable-_disableInitializers--[`++_disableInitializers++`]] :_getInitializedVersion: pass:normal[xref:#Initializable-_getInitializedVersion--[`++_getInitializedVersion++`]] :_isInitializing: pass:normal[xref:#Initializable-_isInitializing--[`++_isInitializing++`]] +:_initializableStorageSlot: pass:normal[xref:#Initializable-_initializableStorageSlot--[`++_initializableStorageSlot++`]] + +:_checkInitializing-: pass:normal[xref:#Initializable-_checkInitializing--[`++_checkInitializing++`]] +:_disableInitializers-: pass:normal[xref:#Initializable-_disableInitializers--[`++_disableInitializers++`]] +:_getInitializedVersion-: pass:normal[xref:#Initializable-_getInitializedVersion--[`++_getInitializedVersion++`]] +:_isInitializing-: pass:normal[xref:#Initializable-_isInitializing--[`++_isInitializing++`]] +:_initializableStorageSlot-: pass:normal[xref:#Initializable-_initializableStorageSlot--[`++_initializableStorageSlot++`]] [.contract] [[Initializable]] -=== `++Initializable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/utils/Initializable.sol[{github-icon},role=heading-link] +=== `++Initializable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/utils/Initializable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1137,6 +1192,7 @@ constructor() { * {xref-Initializable-_disableInitializers--}[`++_disableInitializers()++`] * {xref-Initializable-_getInitializedVersion--}[`++_getInitializedVersion()++`] * {xref-Initializable-_isInitializing--}[`++_isInitializing()++`] +* {xref-Initializable-_initializableStorageSlot--}[`++_initializableStorageSlot()++`] -- @@ -1225,6 +1281,14 @@ Returns the highest version that has been initialized. See {reinitializer}. Returns `true` if the contract is currently initializing. See {onlyInitializing}. +[.contract-item] +[[Initializable-_initializableStorageSlot--]] +==== `[.contract-item-name]#++_initializableStorageSlot++#++() → bytes32++` [.item-kind]#internal# + +Pointer to storage slot. Allows integrators to override it with a custom storage location. + +NOTE: Consider following the ERC-7201 formula to derive storage locations. + [.contract-item] [[Initializable-Initialized-uint64-]] ==== `[.contract-item-name]#++Initialized++#++(uint64 version)++` [.item-kind]#event# @@ -1254,9 +1318,16 @@ The contract is not initializing. :_checkNotDelegated: pass:normal[xref:#UUPSUpgradeable-_checkNotDelegated--[`++_checkNotDelegated++`]] :_authorizeUpgrade: pass:normal[xref:#UUPSUpgradeable-_authorizeUpgrade-address-[`++_authorizeUpgrade++`]] +:proxiableUUID-: pass:normal[xref:#UUPSUpgradeable-proxiableUUID--[`++proxiableUUID++`]] +:upgradeToAndCall-address-bytes: pass:normal[xref:#UUPSUpgradeable-upgradeToAndCall-address-bytes-[`++upgradeToAndCall++`]] +:_checkProxy-: pass:normal[xref:#UUPSUpgradeable-_checkProxy--[`++_checkProxy++`]] +:_checkNotDelegated-: pass:normal[xref:#UUPSUpgradeable-_checkNotDelegated--[`++_checkNotDelegated++`]] +:_authorizeUpgrade-address: pass:normal[xref:#UUPSUpgradeable-_authorizeUpgrade-address-[`++_authorizeUpgrade++`]] +:UPGRADE_INTERFACE_VERSION-string: pass:normal[xref:#UUPSUpgradeable-UPGRADE_INTERFACE_VERSION-string[`++UPGRADE_INTERFACE_VERSION++`]] + [.contract] [[UUPSUpgradeable]] -=== `++UUPSUpgradeable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/proxy/utils/UUPSUpgradeable.sol[{github-icon},role=heading-link] +=== `++UUPSUpgradeable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/proxy/utils/UUPSUpgradeable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1350,7 +1421,6 @@ Emits an {Upgraded} event. Reverts if the execution is not performed via delegatecall or the execution context is not of a proxy with an ERC-1967 compliant implementation pointing to self. -See {_onlyProxy}. [.contract-item] [[UUPSUpgradeable-_checkNotDelegated--]] diff --git a/docs/modules/api/pages/token/ERC1155.adoc b/docs/modules/api/pages/token/ERC1155.adoc index 8840497d0..f58b031c5 100644 --- a/docs/modules/api/pages/token/ERC1155.adoc +++ b/docs/modules/api/pages/token/ERC1155.adoc @@ -19,6 +19,8 @@ :xref-IERC1155-ApprovalForAll-address-address-bool-: xref:token/ERC1155.adoc#IERC1155-ApprovalForAll-address-address-bool- :xref-IERC1155-URI-string-uint256-: xref:token/ERC1155.adoc#IERC1155-URI-string-uint256- :IERC1155Receiver-onERC1155Received: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`IERC1155Receiver.onERC1155Received`]] +:IERC1155Receiver-onERC1155Received: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`IERC1155Receiver.onERC1155Received`]] +:IERC1155Receiver-onERC1155BatchReceived: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`IERC1155Receiver.onERC1155BatchReceived`]] :IERC1155Receiver-onERC1155BatchReceived: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`IERC1155Receiver.onERC1155BatchReceived`]] :IERC1155MetadataURI-uri: pass:normal[xref:token/ERC1155.adoc#IERC1155MetadataURI-uri-uint256-[`IERC1155MetadataURI.uri`]] :xref-IERC1155MetadataURI-uri-uint256-: xref:token/ERC1155.adoc#IERC1155MetadataURI-uri-uint256- @@ -231,6 +233,8 @@ :xref-ERC1155Utils-checkOnERC1155BatchReceived-address-address-address-uint256---uint256---bytes-: xref:token/ERC1155.adoc#ERC1155Utils-checkOnERC1155BatchReceived-address-address-address-uint256---uint256---bytes- :IERC1155Receiver-onERC1155Received: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`IERC1155Receiver.onERC1155Received`]] :IERC1155Receiver-onERC1155Received: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`IERC1155Receiver.onERC1155Received`]] +:IERC1155Receiver-onERC1155BatchReceived: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`IERC1155Receiver.onERC1155BatchReceived`]] +:IERC1155Receiver-onERC1155Received: pass:normal[xref:token/ERC1155.adoc#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`IERC1155Receiver.onERC1155Received`]] = ERC-1155 [.readme-notice] @@ -262,9 +266,16 @@ NOTE: This core set of contracts is designed to be unopinionated, allowing devel :safeTransferFrom: pass:normal[xref:#IERC1155-safeTransferFrom-address-address-uint256-uint256-bytes-[`++safeTransferFrom++`]] :safeBatchTransferFrom: pass:normal[xref:#IERC1155-safeBatchTransferFrom-address-address-uint256---uint256---bytes-[`++safeBatchTransferFrom++`]] +:balanceOf-address-uint256: pass:normal[xref:#IERC1155-balanceOf-address-uint256-[`++balanceOf++`]] +:balanceOfBatch-address---uint256--: pass:normal[xref:#IERC1155-balanceOfBatch-address---uint256---[`++balanceOfBatch++`]] +:setApprovalForAll-address-bool: pass:normal[xref:#IERC1155-setApprovalForAll-address-bool-[`++setApprovalForAll++`]] +:isApprovedForAll-address-address: pass:normal[xref:#IERC1155-isApprovedForAll-address-address-[`++isApprovedForAll++`]] +:safeTransferFrom-address-address-uint256-uint256-bytes: pass:normal[xref:#IERC1155-safeTransferFrom-address-address-uint256-uint256-bytes-[`++safeTransferFrom++`]] +:safeBatchTransferFrom-address-address-uint256---uint256---bytes: pass:normal[xref:#IERC1155-safeBatchTransferFrom-address-address-uint256---uint256---bytes-[`++safeBatchTransferFrom++`]] + [.contract] [[IERC1155]] -=== `++IERC1155++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/IERC1155.sol[{github-icon},role=heading-link] +=== `++IERC1155++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/IERC1155.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -346,7 +357,7 @@ See {setApprovalForAll}. Transfers a `value` amount of tokens of type `id` from `from` to `to`. WARNING: This function can potentially allow a reentrancy attack when transferring tokens -to an untrusted contract, when invoking {onERC1155Received} on the receiver. +to an untrusted contract, when invoking {IERC1155Receiver-onERC1155Received} on the receiver. Ensure to follow the checks-effects-interactions pattern and consider employing reentrancy guards when interacting with untrusted contracts. @@ -367,7 +378,7 @@ acceptance magic value. xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. WARNING: This function can potentially allow a reentrancy attack when transferring tokens -to an untrusted contract, when invoking {onERC1155BatchReceived} on the receiver. +to an untrusted contract, when invoking {IERC1155Receiver-onERC1155BatchReceived} on the receiver. Ensure to follow the checks-effects-interactions pattern and consider employing reentrancy guards when interacting with untrusted contracts. @@ -411,9 +422,11 @@ returned by {IERC1155MetadataURI-uri}. :uri: pass:normal[xref:#IERC1155MetadataURI-uri-uint256-[`++uri++`]] +:uri-uint256: pass:normal[xref:#IERC1155MetadataURI-uri-uint256-[`++uri++`]] + [.contract] [[IERC1155MetadataURI]] -=== `++IERC1155MetadataURI++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol[{github-icon},role=heading-link] +=== `++IERC1155MetadataURI++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -488,9 +501,29 @@ clients with the actual token type ID. :_burnBatch: pass:normal[xref:#ERC1155-_burnBatch-address-uint256---uint256---[`++_burnBatch++`]] :_setApprovalForAll: pass:normal[xref:#ERC1155-_setApprovalForAll-address-address-bool-[`++_setApprovalForAll++`]] +:constructor-string: pass:normal[xref:#ERC1155-constructor-string-[`++constructor++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC1155-supportsInterface-bytes4-[`++supportsInterface++`]] +:uri-uint256: pass:normal[xref:#ERC1155-uri-uint256-[`++uri++`]] +:balanceOf-address-uint256: pass:normal[xref:#ERC1155-balanceOf-address-uint256-[`++balanceOf++`]] +:balanceOfBatch-address---uint256--: pass:normal[xref:#ERC1155-balanceOfBatch-address---uint256---[`++balanceOfBatch++`]] +:setApprovalForAll-address-bool: pass:normal[xref:#ERC1155-setApprovalForAll-address-bool-[`++setApprovalForAll++`]] +:isApprovedForAll-address-address: pass:normal[xref:#ERC1155-isApprovedForAll-address-address-[`++isApprovedForAll++`]] +:safeTransferFrom-address-address-uint256-uint256-bytes: pass:normal[xref:#ERC1155-safeTransferFrom-address-address-uint256-uint256-bytes-[`++safeTransferFrom++`]] +:safeBatchTransferFrom-address-address-uint256---uint256---bytes: pass:normal[xref:#ERC1155-safeBatchTransferFrom-address-address-uint256---uint256---bytes-[`++safeBatchTransferFrom++`]] +:_update-address-address-uint256---uint256--: pass:normal[xref:#ERC1155-_update-address-address-uint256---uint256---[`++_update++`]] +:_updateWithAcceptanceCheck-address-address-uint256---uint256---bytes: pass:normal[xref:#ERC1155-_updateWithAcceptanceCheck-address-address-uint256---uint256---bytes-[`++_updateWithAcceptanceCheck++`]] +:_safeTransferFrom-address-address-uint256-uint256-bytes: pass:normal[xref:#ERC1155-_safeTransferFrom-address-address-uint256-uint256-bytes-[`++_safeTransferFrom++`]] +:_safeBatchTransferFrom-address-address-uint256---uint256---bytes: pass:normal[xref:#ERC1155-_safeBatchTransferFrom-address-address-uint256---uint256---bytes-[`++_safeBatchTransferFrom++`]] +:_setURI-string: pass:normal[xref:#ERC1155-_setURI-string-[`++_setURI++`]] +:_mint-address-uint256-uint256-bytes: pass:normal[xref:#ERC1155-_mint-address-uint256-uint256-bytes-[`++_mint++`]] +:_mintBatch-address-uint256---uint256---bytes: pass:normal[xref:#ERC1155-_mintBatch-address-uint256---uint256---bytes-[`++_mintBatch++`]] +:_burn-address-uint256-uint256: pass:normal[xref:#ERC1155-_burn-address-uint256-uint256-[`++_burn++`]] +:_burnBatch-address-uint256---uint256--: pass:normal[xref:#ERC1155-_burnBatch-address-uint256---uint256---[`++_burnBatch++`]] +:_setApprovalForAll-address-address-bool: pass:normal[xref:#ERC1155-_setApprovalForAll-address-address-bool-[`++_setApprovalForAll++`]] + [.contract] [[ERC1155]] -=== `++ERC1155++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/ERC1155.sol[{github-icon},role=heading-link] +=== `++ERC1155++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/ERC1155.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -810,9 +843,12 @@ Requirements: :onERC1155Received: pass:normal[xref:#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`++onERC1155Received++`]] :onERC1155BatchReceived: pass:normal[xref:#IERC1155Receiver-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`++onERC1155BatchReceived++`]] +:onERC1155Received-address-address-uint256-uint256-bytes: pass:normal[xref:#IERC1155Receiver-onERC1155Received-address-address-uint256-uint256-bytes-[`++onERC1155Received++`]] +:onERC1155BatchReceived-address-address-uint256---uint256---bytes: pass:normal[xref:#IERC1155Receiver-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`++onERC1155BatchReceived++`]] + [.contract] [[IERC1155Receiver]] -=== `++IERC1155Receiver++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/IERC1155Receiver.sol[{github-icon},role=heading-link] +=== `++IERC1155Receiver++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/IERC1155Receiver.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -861,9 +897,11 @@ NOTE: To accept the transfer(s), this must return :_update: pass:normal[xref:#ERC1155Pausable-_update-address-address-uint256---uint256---[`++_update++`]] +:_update-address-address-uint256---uint256--: pass:normal[xref:#ERC1155Pausable-_update-address-address-uint256---uint256---[`++_update++`]] + [.contract] [[ERC1155Pausable]] -=== `++ERC1155Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/extensions/ERC1155Pausable.sol[{github-icon},role=heading-link] +=== `++ERC1155Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/extensions/ERC1155Pausable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1014,9 +1052,12 @@ Requirements: :burn: pass:normal[xref:#ERC1155Burnable-burn-address-uint256-uint256-[`++burn++`]] :burnBatch: pass:normal[xref:#ERC1155Burnable-burnBatch-address-uint256---uint256---[`++burnBatch++`]] +:burn-address-uint256-uint256: pass:normal[xref:#ERC1155Burnable-burn-address-uint256-uint256-[`++burn++`]] +:burnBatch-address-uint256---uint256--: pass:normal[xref:#ERC1155Burnable-burnBatch-address-uint256---uint256---[`++burnBatch++`]] + [.contract] [[ERC1155Burnable]] -=== `++ERC1155Burnable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/extensions/ERC1155Burnable.sol[{github-icon},role=heading-link] +=== `++ERC1155Burnable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/extensions/ERC1155Burnable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1142,9 +1183,14 @@ own tokens and those that they have been approved to use. :exists: pass:normal[xref:#ERC1155Supply-exists-uint256-[`++exists++`]] :_update: pass:normal[xref:#ERC1155Supply-_update-address-address-uint256---uint256---[`++_update++`]] +:totalSupply-uint256: pass:normal[xref:#ERC1155Supply-totalSupply-uint256-[`++totalSupply++`]] +:totalSupply-: pass:normal[xref:#ERC1155Supply-totalSupply--[`++totalSupply++`]] +:exists-uint256: pass:normal[xref:#ERC1155Supply-exists-uint256-[`++exists++`]] +:_update-address-address-uint256---uint256--: pass:normal[xref:#ERC1155Supply-_update-address-address-uint256---uint256---[`++_update++`]] + [.contract] [[ERC1155Supply]] -=== `++ERC1155Supply++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/extensions/ERC1155Supply.sol[{github-icon},role=heading-link] +=== `++ERC1155Supply++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/extensions/ERC1155Supply.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1295,9 +1341,13 @@ See {ERC1155-_update}. :_setURI: pass:normal[xref:#ERC1155URIStorage-_setURI-uint256-string-[`++_setURI++`]] :_setBaseURI: pass:normal[xref:#ERC1155URIStorage-_setBaseURI-string-[`++_setBaseURI++`]] +:uri-uint256: pass:normal[xref:#ERC1155URIStorage-uri-uint256-[`++uri++`]] +:_setURI-uint256-string: pass:normal[xref:#ERC1155URIStorage-_setURI-uint256-string-[`++_setURI++`]] +:_setBaseURI-string: pass:normal[xref:#ERC1155URIStorage-_setBaseURI-string-[`++_setBaseURI++`]] + [.contract] [[ERC1155URIStorage]] -=== `++ERC1155URIStorage++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol[{github-icon},role=heading-link] +=== `++ERC1155URIStorage++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/extensions/ERC1155URIStorage.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1449,9 +1499,13 @@ Sets `baseURI` as the `_baseURI` for all tokens :onERC1155Received: pass:normal[xref:#ERC1155Holder-onERC1155Received-address-address-uint256-uint256-bytes-[`++onERC1155Received++`]] :onERC1155BatchReceived: pass:normal[xref:#ERC1155Holder-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`++onERC1155BatchReceived++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC1155Holder-supportsInterface-bytes4-[`++supportsInterface++`]] +:onERC1155Received-address-address-uint256-uint256-bytes: pass:normal[xref:#ERC1155Holder-onERC1155Received-address-address-uint256-uint256-bytes-[`++onERC1155Received++`]] +:onERC1155BatchReceived-address-address-uint256---uint256---bytes: pass:normal[xref:#ERC1155Holder-onERC1155BatchReceived-address-address-uint256---uint256---bytes-[`++onERC1155BatchReceived++`]] + [.contract] [[ERC1155Holder]] -=== `++ERC1155Holder++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/utils/ERC1155Holder.sol[{github-icon},role=heading-link] +=== `++ERC1155Holder++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/utils/ERC1155Holder.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1498,9 +1552,12 @@ See {IERC165-supportsInterface}. :checkOnERC1155Received: pass:normal[xref:#ERC1155Utils-checkOnERC1155Received-address-address-address-uint256-uint256-bytes-[`++checkOnERC1155Received++`]] :checkOnERC1155BatchReceived: pass:normal[xref:#ERC1155Utils-checkOnERC1155BatchReceived-address-address-address-uint256---uint256---bytes-[`++checkOnERC1155BatchReceived++`]] +:checkOnERC1155Received-address-address-address-uint256-uint256-bytes: pass:normal[xref:#ERC1155Utils-checkOnERC1155Received-address-address-address-uint256-uint256-bytes-[`++checkOnERC1155Received++`]] +:checkOnERC1155BatchReceived-address-address-address-uint256---uint256---bytes: pass:normal[xref:#ERC1155Utils-checkOnERC1155BatchReceived-address-address-address-uint256---uint256---bytes-[`++checkOnERC1155BatchReceived++`]] + [.contract] [[ERC1155Utils]] -=== `++ERC1155Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC1155/utils/ERC1155Utils.sol[{github-icon},role=heading-link] +=== `++ERC1155Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC1155/utils/ERC1155Utils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1525,7 +1582,7 @@ _Available since v5.1._ [[ERC1155Utils-checkOnERC1155Received-address-address-address-uint256-uint256-bytes-]] ==== `[.contract-item-name]#++checkOnERC1155Received++#++(address operator, address from, address to, uint256 id, uint256 value, bytes data)++` [.item-kind]#internal# -Performs an acceptance check for the provided `operator` by calling {IERC1155-onERC1155Received} +Performs an acceptance check for the provided `operator` by calling {IERC1155Receiver-onERC1155Received} on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). @@ -1536,7 +1593,7 @@ the transfer. [[ERC1155Utils-checkOnERC1155BatchReceived-address-address-address-uint256---uint256---bytes-]] ==== `[.contract-item-name]#++checkOnERC1155BatchReceived++#++(address operator, address from, address to, uint256[] ids, uint256[] values, bytes data)++` [.item-kind]#internal# -Performs a batch acceptance check for the provided `operator` by calling {IERC1155-onERC1155BatchReceived} +Performs a batch acceptance check for the provided `operator` by calling {IERC1155Receiver-onERC1155BatchReceived} on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). diff --git a/docs/modules/api/pages/token/ERC20.adoc b/docs/modules/api/pages/token/ERC20.adoc index 932633bf3..f0a50b8e4 100644 --- a/docs/modules/api/pages/token/ERC20.adoc +++ b/docs/modules/api/pages/token/ERC20.adoc @@ -499,6 +499,8 @@ :IERC4626-redeem: pass:normal[xref:interfaces.adoc#IERC4626-redeem-uint256-address-address-[`IERC4626.redeem`]] :xref-SafeERC20-safeTransfer-contract-IERC20-address-uint256-: xref:token/ERC20.adoc#SafeERC20-safeTransfer-contract-IERC20-address-uint256- :xref-SafeERC20-safeTransferFrom-contract-IERC20-address-address-uint256-: xref:token/ERC20.adoc#SafeERC20-safeTransferFrom-contract-IERC20-address-address-uint256- +:xref-SafeERC20-trySafeTransfer-contract-IERC20-address-uint256-: xref:token/ERC20.adoc#SafeERC20-trySafeTransfer-contract-IERC20-address-uint256- +:xref-SafeERC20-trySafeTransferFrom-contract-IERC20-address-address-uint256-: xref:token/ERC20.adoc#SafeERC20-trySafeTransferFrom-contract-IERC20-address-address-uint256- :xref-SafeERC20-safeIncreaseAllowance-contract-IERC20-address-uint256-: xref:token/ERC20.adoc#SafeERC20-safeIncreaseAllowance-contract-IERC20-address-uint256- :xref-SafeERC20-safeDecreaseAllowance-contract-IERC20-address-uint256-: xref:token/ERC20.adoc#SafeERC20-safeDecreaseAllowance-contract-IERC20-address-uint256- :xref-SafeERC20-forceApprove-contract-IERC20-address-uint256-: xref:token/ERC20.adoc#SafeERC20-forceApprove-contract-IERC20-address-uint256- @@ -539,11 +541,11 @@ This set of interfaces, contracts, and utilities are all related to the https:// TIP: For an overview of ERC-20 tokens and a walk through on how to create a token contract read our xref:ROOT:erc20.adoc[ERC-20 guide]. -There are a few core contracts that implement the behavior specified in the ERC: +There are a few core contracts that implement the behavior specified in the ERC-20 standard: * {IERC20}: the interface all ERC-20 implementations should conform to. -* {IERC20Metadata}: the extended ERC-20 interface including the <>, <> and <> functions. -* {ERC20}: the implementation of the ERC-20 interface, including the <>, <> and <> optional standard extension to the base interface. +* {IERC20Metadata}: the extended ERC-20 interface including the <>, <> and <> functions. +* {ERC20}: the implementation of the ERC-20 interface, including the <>, <> and <> optional extensions to the standard interface. Additionally there are multiple custom extensions, including: @@ -562,9 +564,9 @@ Finally, there are some utilities to interact with ERC-20 contracts in various w * {SafeERC20}: a wrapper around the interface that eliminates the need to handle boolean return values. -Other utilities that support ERC-20 assets can be found in codebase: +Other utilities that support ERC-20 assets can be found in the codebase: -* ERC-20 tokens can be timelocked (held tokens for a beneficiary until a specified time) or vested (released following a given schedule) using a {VestingWallet}. +* ERC-20 tokens can be timelocked (held for a beneficiary until a specified time) or vested (released following a given schedule) using a {VestingWallet}. NOTE: This core set of contracts is designed to be unopinionated, allowing developers to access the internal functions in ERC-20 (such as <>) and expose them as external functions in the way they prefer. @@ -579,9 +581,16 @@ NOTE: This core set of contracts is designed to be unopinionated, allowing devel :approve: pass:normal[xref:#IERC20-approve-address-uint256-[`++approve++`]] :transferFrom: pass:normal[xref:#IERC20-transferFrom-address-address-uint256-[`++transferFrom++`]] +:totalSupply-: pass:normal[xref:#IERC20-totalSupply--[`++totalSupply++`]] +:balanceOf-address: pass:normal[xref:#IERC20-balanceOf-address-[`++balanceOf++`]] +:transfer-address-uint256: pass:normal[xref:#IERC20-transfer-address-uint256-[`++transfer++`]] +:allowance-address-address: pass:normal[xref:#IERC20-allowance-address-address-[`++allowance++`]] +:approve-address-uint256: pass:normal[xref:#IERC20-approve-address-uint256-[`++approve++`]] +:transferFrom-address-address-uint256: pass:normal[xref:#IERC20-transferFrom-address-address-uint256-[`++transferFrom++`]] + [.contract] [[IERC20]] -=== `++IERC20++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/IERC20.sol[{github-icon},role=heading-link] +=== `++IERC20++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/IERC20.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -692,9 +701,13 @@ a call to {approve}. `value` is the new allowance. :symbol: pass:normal[xref:#IERC20Metadata-symbol--[`++symbol++`]] :decimals: pass:normal[xref:#IERC20Metadata-decimals--[`++decimals++`]] +:name-: pass:normal[xref:#IERC20Metadata-name--[`++name++`]] +:symbol-: pass:normal[xref:#IERC20Metadata-symbol--[`++symbol++`]] +:decimals-: pass:normal[xref:#IERC20Metadata-decimals--[`++decimals++`]] + [.contract] [[IERC20Metadata]] -=== `++IERC20Metadata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/IERC20Metadata.sol[{github-icon},role=heading-link] +=== `++IERC20Metadata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/IERC20Metadata.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -768,9 +781,27 @@ Returns the decimals places of the token. :_approve: pass:normal[xref:#ERC20-_approve-address-address-uint256-bool-[`++_approve++`]] :_spendAllowance: pass:normal[xref:#ERC20-_spendAllowance-address-address-uint256-[`++_spendAllowance++`]] +:constructor-string-string: pass:normal[xref:#ERC20-constructor-string-string-[`++constructor++`]] +:name-: pass:normal[xref:#ERC20-name--[`++name++`]] +:symbol-: pass:normal[xref:#ERC20-symbol--[`++symbol++`]] +:decimals-: pass:normal[xref:#ERC20-decimals--[`++decimals++`]] +:totalSupply-: pass:normal[xref:#ERC20-totalSupply--[`++totalSupply++`]] +:balanceOf-address: pass:normal[xref:#ERC20-balanceOf-address-[`++balanceOf++`]] +:transfer-address-uint256: pass:normal[xref:#ERC20-transfer-address-uint256-[`++transfer++`]] +:allowance-address-address: pass:normal[xref:#ERC20-allowance-address-address-[`++allowance++`]] +:approve-address-uint256: pass:normal[xref:#ERC20-approve-address-uint256-[`++approve++`]] +:transferFrom-address-address-uint256: pass:normal[xref:#ERC20-transferFrom-address-address-uint256-[`++transferFrom++`]] +:_transfer-address-address-uint256: pass:normal[xref:#ERC20-_transfer-address-address-uint256-[`++_transfer++`]] +:_update-address-address-uint256: pass:normal[xref:#ERC20-_update-address-address-uint256-[`++_update++`]] +:_mint-address-uint256: pass:normal[xref:#ERC20-_mint-address-uint256-[`++_mint++`]] +:_burn-address-uint256: pass:normal[xref:#ERC20-_burn-address-uint256-[`++_burn++`]] +:_approve-address-address-uint256: pass:normal[xref:#ERC20-_approve-address-address-uint256-[`++_approve++`]] +:_approve-address-address-uint256-bool: pass:normal[xref:#ERC20-_approve-address-address-uint256-bool-[`++_approve++`]] +:_spendAllowance-address-address-uint256: pass:normal[xref:#ERC20-_spendAllowance-address-address-uint256-[`++_spendAllowance++`]] + [.contract] [[ERC20]] -=== `++ERC20++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/ERC20.sol[{github-icon},role=heading-link] +=== `++ERC20++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/ERC20.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -870,8 +901,7 @@ applications. Sets the values for {name} and {symbol}. -All two of these values are immutable: they can only be set once during -construction. +Both values are immutable: they can only be set once during construction. [.contract-item] [[ERC20-name--]] @@ -1012,7 +1042,7 @@ NOTE: This function is not virtual, {_update} should be overridden instead [[ERC20-_approve-address-address-uint256-]] ==== `[.contract-item-name]#++_approve++#++(address owner, address spender, uint256 value)++` [.item-kind]#internal# -Sets `value` as the allowance of `spender` over the `owner` s tokens. +Sets `value` as the allowance of `spender` over the `owner`'s tokens. This internal function is equivalent to `approve`, and can be used to e.g. set automatic allowances for certain subsystems, etc. @@ -1051,7 +1081,7 @@ Requirements are the same as {_approve}. [[ERC20-_spendAllowance-address-address-uint256-]] ==== `[.contract-item-name]#++_spendAllowance++#++(address owner, address spender, uint256 value)++` [.item-kind]#internal# -Updates `owner` s allowance for `spender` based on spent `value`. +Updates `owner`'s allowance for `spender` based on spent `value`. Does not update the allowance value in case of infinite allowance. Revert if not enough allowance is available. @@ -1064,9 +1094,13 @@ Does not emit an {Approval} event. :nonces: pass:normal[xref:#IERC20Permit-nonces-address-[`++nonces++`]] :DOMAIN_SEPARATOR: pass:normal[xref:#IERC20Permit-DOMAIN_SEPARATOR--[`++DOMAIN_SEPARATOR++`]] +:permit-address-address-uint256-uint256-uint8-bytes32-bytes32: pass:normal[xref:#IERC20Permit-permit-address-address-uint256-uint256-uint8-bytes32-bytes32-[`++permit++`]] +:nonces-address: pass:normal[xref:#IERC20Permit-nonces-address-[`++nonces++`]] +:DOMAIN_SEPARATOR-: pass:normal[xref:#IERC20Permit-DOMAIN_SEPARATOR--[`++DOMAIN_SEPARATOR++`]] + [.contract] [[IERC20Permit]] -=== `++IERC20Permit++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/IERC20Permit.sol[{github-icon},role=heading-link] +=== `++IERC20Permit++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/IERC20Permit.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1166,9 +1200,14 @@ Returns the domain separator used in the encoding of the signature for {permit}, :nonces: pass:normal[xref:#ERC20Permit-nonces-address-[`++nonces++`]] :DOMAIN_SEPARATOR: pass:normal[xref:#ERC20Permit-DOMAIN_SEPARATOR--[`++DOMAIN_SEPARATOR++`]] +:constructor-string: pass:normal[xref:#ERC20Permit-constructor-string-[`++constructor++`]] +:permit-address-address-uint256-uint256-uint8-bytes32-bytes32: pass:normal[xref:#ERC20Permit-permit-address-address-uint256-uint256-uint8-bytes32-bytes32-[`++permit++`]] +:nonces-address: pass:normal[xref:#ERC20Permit-nonces-address-[`++nonces++`]] +:DOMAIN_SEPARATOR-: pass:normal[xref:#ERC20Permit-DOMAIN_SEPARATOR--[`++DOMAIN_SEPARATOR++`]] + [.contract] [[ERC20Permit]] -=== `++ERC20Permit++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20Permit.sol[{github-icon},role=heading-link] +=== `++ERC20Permit++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20Permit.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1376,9 +1415,12 @@ Mismatched signature. :burn: pass:normal[xref:#ERC20Burnable-burn-uint256-[`++burn++`]] :burnFrom: pass:normal[xref:#ERC20Burnable-burnFrom-address-uint256-[`++burnFrom++`]] +:burn-uint256: pass:normal[xref:#ERC20Burnable-burn-uint256-[`++burn++`]] +:burnFrom-address-uint256: pass:normal[xref:#ERC20Burnable-burnFrom-address-uint256-[`++burnFrom++`]] + [.contract] [[ERC20Burnable]] -=== `++ERC20Burnable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20Burnable.sol[{github-icon},role=heading-link] +=== `++ERC20Burnable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20Burnable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1497,9 +1539,13 @@ Requirements: :cap: pass:normal[xref:#ERC20Capped-cap--[`++cap++`]] :_update: pass:normal[xref:#ERC20Capped-_update-address-address-uint256-[`++_update++`]] +:constructor-uint256: pass:normal[xref:#ERC20Capped-constructor-uint256-[`++constructor++`]] +:cap-: pass:normal[xref:#ERC20Capped-cap--[`++cap++`]] +:_update-address-address-uint256: pass:normal[xref:#ERC20Capped-_update-address-address-uint256-[`++_update++`]] + [.contract] [[ERC20Capped]] -=== `++ERC20Capped++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20Capped.sol[{github-icon},role=heading-link] +=== `++ERC20Capped++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20Capped.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1623,9 +1669,11 @@ The supplied cap is not a valid cap. :_update: pass:normal[xref:#ERC20Pausable-_update-address-address-uint256-[`++_update++`]] +:_update-address-address-uint256: pass:normal[xref:#ERC20Pausable-_update-address-address-uint256-[`++_update++`]] + [.contract] [[ERC20Pausable]] -=== `++ERC20Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20Pausable.sol[{github-icon},role=heading-link] +=== `++ERC20Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20Pausable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1757,9 +1805,15 @@ Requirements: :numCheckpoints: pass:normal[xref:#ERC20Votes-numCheckpoints-address-[`++numCheckpoints++`]] :checkpoints: pass:normal[xref:#ERC20Votes-checkpoints-address-uint32-[`++checkpoints++`]] +:_maxSupply-: pass:normal[xref:#ERC20Votes-_maxSupply--[`++_maxSupply++`]] +:_update-address-address-uint256: pass:normal[xref:#ERC20Votes-_update-address-address-uint256-[`++_update++`]] +:_getVotingUnits-address: pass:normal[xref:#ERC20Votes-_getVotingUnits-address-[`++_getVotingUnits++`]] +:numCheckpoints-address: pass:normal[xref:#ERC20Votes-numCheckpoints-address-[`++numCheckpoints++`]] +:checkpoints-address-uint32: pass:normal[xref:#ERC20Votes-checkpoints-address-uint32-[`++checkpoints++`]] + [.contract] [[ERC20Votes]] -=== `++ERC20Votes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20Votes.sol[{github-icon},role=heading-link] +=== `++ERC20Votes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20Votes.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2010,9 +2064,16 @@ Total supply cap has been exceeded, introducing a risk of votes overflowing. :withdrawTo: pass:normal[xref:#ERC20Wrapper-withdrawTo-address-uint256-[`++withdrawTo++`]] :_recover: pass:normal[xref:#ERC20Wrapper-_recover-address-[`++_recover++`]] +:constructor-contract-IERC20: pass:normal[xref:#ERC20Wrapper-constructor-contract-IERC20-[`++constructor++`]] +:decimals-: pass:normal[xref:#ERC20Wrapper-decimals--[`++decimals++`]] +:underlying-: pass:normal[xref:#ERC20Wrapper-underlying--[`++underlying++`]] +:depositFor-address-uint256: pass:normal[xref:#ERC20Wrapper-depositFor-address-uint256-[`++depositFor++`]] +:withdrawTo-address-uint256: pass:normal[xref:#ERC20Wrapper-withdrawTo-address-uint256-[`++withdrawTo++`]] +:_recover-address: pass:normal[xref:#ERC20Wrapper-_recover-address-[`++_recover++`]] + [.contract] [[ERC20Wrapper]] -=== `++ERC20Wrapper++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20Wrapper.sol[{github-icon},role=heading-link] +=== `++ERC20Wrapper++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20Wrapper.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2164,9 +2225,15 @@ The underlying token couldn't be wrapped. :_flashFeeReceiver: pass:normal[xref:#ERC20FlashMint-_flashFeeReceiver--[`++_flashFeeReceiver++`]] :flashLoan: pass:normal[xref:#ERC20FlashMint-flashLoan-contract-IERC3156FlashBorrower-address-uint256-bytes-[`++flashLoan++`]] +:maxFlashLoan-address: pass:normal[xref:#ERC20FlashMint-maxFlashLoan-address-[`++maxFlashLoan++`]] +:flashFee-address-uint256: pass:normal[xref:#ERC20FlashMint-flashFee-address-uint256-[`++flashFee++`]] +:_flashFee-address-uint256: pass:normal[xref:#ERC20FlashMint-_flashFee-address-uint256-[`++_flashFee++`]] +:_flashFeeReceiver-: pass:normal[xref:#ERC20FlashMint-_flashFeeReceiver--[`++_flashFeeReceiver++`]] +:flashLoan-contract-IERC3156FlashBorrower-address-uint256-bytes: pass:normal[xref:#ERC20FlashMint-flashLoan-contract-IERC3156FlashBorrower-address-uint256-bytes-[`++flashLoan++`]] + [.contract] [[ERC20FlashMint]] -=== `++ERC20FlashMint++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC20FlashMint.sol[{github-icon},role=heading-link] +=== `++ERC20FlashMint++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC20FlashMint.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2342,9 +2409,15 @@ The receiver of a flashloan is not a valid {IERC3156FlashBorrower-onFlashLoan} i :_temporaryApprove: pass:normal[xref:#ERC20TemporaryApproval-_temporaryApprove-address-address-uint256-[`++_temporaryApprove++`]] :_spendAllowance: pass:normal[xref:#ERC20TemporaryApproval-_spendAllowance-address-address-uint256-[`++_spendAllowance++`]] +:allowance-address-address: pass:normal[xref:#ERC20TemporaryApproval-allowance-address-address-[`++allowance++`]] +:_temporaryAllowance-address-address: pass:normal[xref:#ERC20TemporaryApproval-_temporaryAllowance-address-address-[`++_temporaryAllowance++`]] +:temporaryApprove-address-uint256: pass:normal[xref:#ERC20TemporaryApproval-temporaryApprove-address-uint256-[`++temporaryApprove++`]] +:_temporaryApprove-address-address-uint256: pass:normal[xref:#ERC20TemporaryApproval-_temporaryApprove-address-address-uint256-[`++_temporaryApprove++`]] +:_spendAllowance-address-address-uint256: pass:normal[xref:#ERC20TemporaryApproval-_spendAllowance-address-address-uint256-[`++_spendAllowance++`]] + [.contract] [[ERC20TemporaryApproval]] -=== `++ERC20TemporaryApproval++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/draft-ERC20TemporaryApproval.sol[{github-icon},role=heading-link] +=== `++ERC20TemporaryApproval++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/draft-ERC20TemporaryApproval.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2478,7 +2551,7 @@ Does NOT emit an {Approval} event. [[ERC20TemporaryApproval-_temporaryApprove-address-address-uint256-]] ==== `[.contract-item-name]#++_temporaryApprove++#++(address owner, address spender, uint256 value)++` [.item-kind]#internal# -Sets `value` as the temporary allowance of `spender` over the `owner` s tokens. +Sets `value` as the temporary allowance of `spender` over the `owner`'s tokens. This internal function is equivalent to `temporaryApprove`, and can be used to e.g. set automatic allowances for certain subsystems, etc. @@ -2509,9 +2582,17 @@ is enough to cover the spending. :approveAndCall: pass:normal[xref:#ERC1363-approveAndCall-address-uint256-[`++approveAndCall++`]] :approveAndCall: pass:normal[xref:#ERC1363-approveAndCall-address-uint256-bytes-[`++approveAndCall++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC1363-supportsInterface-bytes4-[`++supportsInterface++`]] +:transferAndCall-address-uint256: pass:normal[xref:#ERC1363-transferAndCall-address-uint256-[`++transferAndCall++`]] +:transferAndCall-address-uint256-bytes: pass:normal[xref:#ERC1363-transferAndCall-address-uint256-bytes-[`++transferAndCall++`]] +:transferFromAndCall-address-address-uint256: pass:normal[xref:#ERC1363-transferFromAndCall-address-address-uint256-[`++transferFromAndCall++`]] +:transferFromAndCall-address-address-uint256-bytes: pass:normal[xref:#ERC1363-transferFromAndCall-address-address-uint256-bytes-[`++transferFromAndCall++`]] +:approveAndCall-address-uint256: pass:normal[xref:#ERC1363-approveAndCall-address-uint256-[`++approveAndCall++`]] +:approveAndCall-address-uint256-bytes: pass:normal[xref:#ERC1363-approveAndCall-address-uint256-bytes-[`++approveAndCall++`]] + [.contract] [[ERC1363]] -=== `++ERC1363++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC1363.sol[{github-icon},role=heading-link] +=== `++ERC1363++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC1363.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2762,9 +2843,33 @@ Indicates a failure within the {approve} part of a approveAndCall operation. :_withdraw: pass:normal[xref:#ERC4626-_withdraw-address-address-address-uint256-uint256-[`++_withdraw++`]] :_decimalsOffset: pass:normal[xref:#ERC4626-_decimalsOffset--[`++_decimalsOffset++`]] +:constructor-contract-IERC20: pass:normal[xref:#ERC4626-constructor-contract-IERC20-[`++constructor++`]] +:decimals-: pass:normal[xref:#ERC4626-decimals--[`++decimals++`]] +:asset-: pass:normal[xref:#ERC4626-asset--[`++asset++`]] +:totalAssets-: pass:normal[xref:#ERC4626-totalAssets--[`++totalAssets++`]] +:convertToShares-uint256: pass:normal[xref:#ERC4626-convertToShares-uint256-[`++convertToShares++`]] +:convertToAssets-uint256: pass:normal[xref:#ERC4626-convertToAssets-uint256-[`++convertToAssets++`]] +:maxDeposit-address: pass:normal[xref:#ERC4626-maxDeposit-address-[`++maxDeposit++`]] +:maxMint-address: pass:normal[xref:#ERC4626-maxMint-address-[`++maxMint++`]] +:maxWithdraw-address: pass:normal[xref:#ERC4626-maxWithdraw-address-[`++maxWithdraw++`]] +:maxRedeem-address: pass:normal[xref:#ERC4626-maxRedeem-address-[`++maxRedeem++`]] +:previewDeposit-uint256: pass:normal[xref:#ERC4626-previewDeposit-uint256-[`++previewDeposit++`]] +:previewMint-uint256: pass:normal[xref:#ERC4626-previewMint-uint256-[`++previewMint++`]] +:previewWithdraw-uint256: pass:normal[xref:#ERC4626-previewWithdraw-uint256-[`++previewWithdraw++`]] +:previewRedeem-uint256: pass:normal[xref:#ERC4626-previewRedeem-uint256-[`++previewRedeem++`]] +:deposit-uint256-address: pass:normal[xref:#ERC4626-deposit-uint256-address-[`++deposit++`]] +:mint-uint256-address: pass:normal[xref:#ERC4626-mint-uint256-address-[`++mint++`]] +:withdraw-uint256-address-address: pass:normal[xref:#ERC4626-withdraw-uint256-address-address-[`++withdraw++`]] +:redeem-uint256-address-address: pass:normal[xref:#ERC4626-redeem-uint256-address-address-[`++redeem++`]] +:_convertToShares-uint256-enum-Math-Rounding: pass:normal[xref:#ERC4626-_convertToShares-uint256-enum-Math-Rounding-[`++_convertToShares++`]] +:_convertToAssets-uint256-enum-Math-Rounding: pass:normal[xref:#ERC4626-_convertToAssets-uint256-enum-Math-Rounding-[`++_convertToAssets++`]] +:_deposit-address-address-uint256-uint256: pass:normal[xref:#ERC4626-_deposit-address-address-uint256-uint256-[`++_deposit++`]] +:_withdraw-address-address-address-uint256-uint256: pass:normal[xref:#ERC4626-_withdraw-address-address-address-uint256-uint256-[`++_withdraw++`]] +:_decimalsOffset-: pass:normal[xref:#ERC4626-_decimalsOffset--[`++_decimalsOffset++`]] + [.contract] [[ERC4626]] -=== `++ERC4626++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/extensions/ERC4626.sol[{github-icon},role=heading-link] +=== `++ERC4626++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/extensions/ERC4626.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2796,7 +2901,7 @@ itself determines the initial exchange rate. While not fully preventing the atta offset (0) makes it non-profitable even if an attacker is able to capture value from multiple user deposits, as a result of the value being captured by the virtual shares (out of the attacker's donation) matching the attacker's expected gains. With a larger offset, the attack becomes orders of magnitude more expensive than it is profitable. More details about the -underlying math can be found xref:erc4626.adoc#inflation-attack[here]. +underlying math can be found xref:ROOT:erc4626.adoc#inflation-attack[here]. The drawback of this approach is that the virtual shares do capture (a very small) part of the value being accrued to the vault. Also, if the vault experiences losses, the users try to exit the vault, the virtual shares and assets @@ -3092,6 +3197,8 @@ Attempted to redeem more shares than the max amount for `receiver`. :SafeERC20FailedDecreaseAllowance: pass:normal[xref:#SafeERC20-SafeERC20FailedDecreaseAllowance-address-uint256-uint256-[`++SafeERC20FailedDecreaseAllowance++`]] :safeTransfer: pass:normal[xref:#SafeERC20-safeTransfer-contract-IERC20-address-uint256-[`++safeTransfer++`]] :safeTransferFrom: pass:normal[xref:#SafeERC20-safeTransferFrom-contract-IERC20-address-address-uint256-[`++safeTransferFrom++`]] +:trySafeTransfer: pass:normal[xref:#SafeERC20-trySafeTransfer-contract-IERC20-address-uint256-[`++trySafeTransfer++`]] +:trySafeTransferFrom: pass:normal[xref:#SafeERC20-trySafeTransferFrom-contract-IERC20-address-address-uint256-[`++trySafeTransferFrom++`]] :safeIncreaseAllowance: pass:normal[xref:#SafeERC20-safeIncreaseAllowance-contract-IERC20-address-uint256-[`++safeIncreaseAllowance++`]] :safeDecreaseAllowance: pass:normal[xref:#SafeERC20-safeDecreaseAllowance-contract-IERC20-address-uint256-[`++safeDecreaseAllowance++`]] :forceApprove: pass:normal[xref:#SafeERC20-forceApprove-contract-IERC20-address-uint256-[`++forceApprove++`]] @@ -3099,9 +3206,20 @@ Attempted to redeem more shares than the max amount for `receiver`. :transferFromAndCallRelaxed: pass:normal[xref:#SafeERC20-transferFromAndCallRelaxed-contract-IERC1363-address-address-uint256-bytes-[`++transferFromAndCallRelaxed++`]] :approveAndCallRelaxed: pass:normal[xref:#SafeERC20-approveAndCallRelaxed-contract-IERC1363-address-uint256-bytes-[`++approveAndCallRelaxed++`]] +:safeTransfer-contract-IERC20-address-uint256: pass:normal[xref:#SafeERC20-safeTransfer-contract-IERC20-address-uint256-[`++safeTransfer++`]] +:safeTransferFrom-contract-IERC20-address-address-uint256: pass:normal[xref:#SafeERC20-safeTransferFrom-contract-IERC20-address-address-uint256-[`++safeTransferFrom++`]] +:trySafeTransfer-contract-IERC20-address-uint256: pass:normal[xref:#SafeERC20-trySafeTransfer-contract-IERC20-address-uint256-[`++trySafeTransfer++`]] +:trySafeTransferFrom-contract-IERC20-address-address-uint256: pass:normal[xref:#SafeERC20-trySafeTransferFrom-contract-IERC20-address-address-uint256-[`++trySafeTransferFrom++`]] +:safeIncreaseAllowance-contract-IERC20-address-uint256: pass:normal[xref:#SafeERC20-safeIncreaseAllowance-contract-IERC20-address-uint256-[`++safeIncreaseAllowance++`]] +:safeDecreaseAllowance-contract-IERC20-address-uint256: pass:normal[xref:#SafeERC20-safeDecreaseAllowance-contract-IERC20-address-uint256-[`++safeDecreaseAllowance++`]] +:forceApprove-contract-IERC20-address-uint256: pass:normal[xref:#SafeERC20-forceApprove-contract-IERC20-address-uint256-[`++forceApprove++`]] +:transferAndCallRelaxed-contract-IERC1363-address-uint256-bytes: pass:normal[xref:#SafeERC20-transferAndCallRelaxed-contract-IERC1363-address-uint256-bytes-[`++transferAndCallRelaxed++`]] +:transferFromAndCallRelaxed-contract-IERC1363-address-address-uint256-bytes: pass:normal[xref:#SafeERC20-transferFromAndCallRelaxed-contract-IERC1363-address-address-uint256-bytes-[`++transferFromAndCallRelaxed++`]] +:approveAndCallRelaxed-contract-IERC1363-address-uint256-bytes: pass:normal[xref:#SafeERC20-approveAndCallRelaxed-contract-IERC1363-address-uint256-bytes-[`++approveAndCallRelaxed++`]] + [.contract] [[SafeERC20]] -=== `++SafeERC20++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/utils/SafeERC20.sol[{github-icon},role=heading-link] +=== `++SafeERC20++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/utils/SafeERC20.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3120,6 +3238,8 @@ which allows you to call the safe operations as `token.safeTransfer(...)`, etc. -- * {xref-SafeERC20-safeTransfer-contract-IERC20-address-uint256-}[`++safeTransfer(token, to, value)++`] * {xref-SafeERC20-safeTransferFrom-contract-IERC20-address-address-uint256-}[`++safeTransferFrom(token, from, to, value)++`] +* {xref-SafeERC20-trySafeTransfer-contract-IERC20-address-uint256-}[`++trySafeTransfer(token, to, value)++`] +* {xref-SafeERC20-trySafeTransferFrom-contract-IERC20-address-address-uint256-}[`++trySafeTransferFrom(token, from, to, value)++`] * {xref-SafeERC20-safeIncreaseAllowance-contract-IERC20-address-uint256-}[`++safeIncreaseAllowance(token, spender, value)++`] * {xref-SafeERC20-safeDecreaseAllowance-contract-IERC20-address-uint256-}[`++safeDecreaseAllowance(token, spender, requestedDecrease)++`] * {xref-SafeERC20-forceApprove-contract-IERC20-address-uint256-}[`++forceApprove(token, spender, value)++`] @@ -3151,6 +3271,18 @@ non-reverting calls are assumed to be successful. Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the calling contract. If `token` returns no value, non-reverting calls are assumed to be successful. +[.contract-item] +[[SafeERC20-trySafeTransfer-contract-IERC20-address-uint256-]] +==== `[.contract-item-name]#++trySafeTransfer++#++(contract IERC20 token, address to, uint256 value) → bool++` [.item-kind]#internal# + +Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful. + +[.contract-item] +[[SafeERC20-trySafeTransferFrom-contract-IERC20-address-address-uint256-]] +==== `[.contract-item-name]#++trySafeTransferFrom++#++(contract IERC20 token, address from, address to, uint256 value) → bool++` [.item-kind]#internal# + +Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful. + [.contract-item] [[SafeERC20-safeIncreaseAllowance-contract-IERC20-address-uint256-]] ==== `[.contract-item-name]#++safeIncreaseAllowance++#++(contract IERC20 token, address spender, uint256 value)++` [.item-kind]#internal# @@ -3238,9 +3370,12 @@ Indicates a failed `decreaseAllowance` request. :checkOnERC1363TransferReceived: pass:normal[xref:#ERC1363Utils-checkOnERC1363TransferReceived-address-address-address-uint256-bytes-[`++checkOnERC1363TransferReceived++`]] :checkOnERC1363ApprovalReceived: pass:normal[xref:#ERC1363Utils-checkOnERC1363ApprovalReceived-address-address-uint256-bytes-[`++checkOnERC1363ApprovalReceived++`]] +:checkOnERC1363TransferReceived-address-address-address-uint256-bytes: pass:normal[xref:#ERC1363Utils-checkOnERC1363TransferReceived-address-address-address-uint256-bytes-[`++checkOnERC1363TransferReceived++`]] +:checkOnERC1363ApprovalReceived-address-address-uint256-bytes: pass:normal[xref:#ERC1363Utils-checkOnERC1363ApprovalReceived-address-address-uint256-bytes-[`++checkOnERC1363ApprovalReceived++`]] + [.contract] [[ERC1363Utils]] -=== `++ERC1363Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC20/utils/ERC1363Utils.sol[{github-icon},role=heading-link] +=== `++ERC1363Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC20/utils/ERC1363Utils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity diff --git a/docs/modules/api/pages/token/ERC6909.adoc b/docs/modules/api/pages/token/ERC6909.adoc new file mode 100644 index 000000000..637f5ac4c --- /dev/null +++ b/docs/modules/api/pages/token/ERC6909.adoc @@ -0,0 +1,891 @@ +:github-icon: pass:[] +:IERC6909: pass:normal[xref:interfaces.adoc#IERC6909[`IERC6909`]] +:IERC6909ContentURI: pass:normal[xref:interfaces.adoc#IERC6909ContentURI[`IERC6909ContentURI`]] +:IERC6909Metadata: pass:normal[xref:interfaces.adoc#IERC6909Metadata[`IERC6909Metadata`]] +:IERC6909TokenSupply: pass:normal[xref:interfaces.adoc#IERC6909TokenSupply[`IERC6909TokenSupply`]] +:xref-ERC6909-supportsInterface-bytes4-: xref:token/ERC6909.adoc#ERC6909-supportsInterface-bytes4- +:xref-ERC6909-balanceOf-address-uint256-: xref:token/ERC6909.adoc#ERC6909-balanceOf-address-uint256- +:xref-ERC6909-allowance-address-address-uint256-: xref:token/ERC6909.adoc#ERC6909-allowance-address-address-uint256- +:xref-ERC6909-isOperator-address-address-: xref:token/ERC6909.adoc#ERC6909-isOperator-address-address- +:xref-ERC6909-approve-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-approve-address-uint256-uint256- +:xref-ERC6909-setOperator-address-bool-: xref:token/ERC6909.adoc#ERC6909-setOperator-address-bool- +:xref-ERC6909-transfer-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transfer-address-uint256-uint256- +:xref-ERC6909-transferFrom-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transferFrom-address-address-uint256-uint256- +:xref-ERC6909-_mint-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_mint-address-uint256-uint256- +:xref-ERC6909-_transfer-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_transfer-address-address-uint256-uint256- +:xref-ERC6909-_burn-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_burn-address-uint256-uint256- +:xref-ERC6909-_update-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_update-address-address-uint256-uint256- +:xref-ERC6909-_approve-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_approve-address-address-uint256-uint256- +:xref-ERC6909-_setOperator-address-address-bool-: xref:token/ERC6909.adoc#ERC6909-_setOperator-address-address-bool- +:xref-ERC6909-_spendAllowance-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_spendAllowance-address-address-uint256-uint256- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InvalidApprover-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidApprover-address- +:xref-ERC6909-ERC6909InvalidReceiver-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidReceiver-address- +:xref-ERC6909-ERC6909InvalidSender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSender-address- +:xref-ERC6909-ERC6909InvalidSpender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSpender-address- +:xref-ERC6909ContentURI-contractURI--: xref:token/ERC6909.adoc#ERC6909ContentURI-contractURI-- +:xref-ERC6909ContentURI-tokenURI-uint256-: xref:token/ERC6909.adoc#ERC6909ContentURI-tokenURI-uint256- +:xref-ERC6909ContentURI-_setContractURI-string-: xref:token/ERC6909.adoc#ERC6909ContentURI-_setContractURI-string- +:xref-ERC6909ContentURI-_setTokenURI-uint256-string-: xref:token/ERC6909.adoc#ERC6909ContentURI-_setTokenURI-uint256-string- +:xref-ERC6909-supportsInterface-bytes4-: xref:token/ERC6909.adoc#ERC6909-supportsInterface-bytes4- +:xref-ERC6909-balanceOf-address-uint256-: xref:token/ERC6909.adoc#ERC6909-balanceOf-address-uint256- +:xref-ERC6909-allowance-address-address-uint256-: xref:token/ERC6909.adoc#ERC6909-allowance-address-address-uint256- +:xref-ERC6909-isOperator-address-address-: xref:token/ERC6909.adoc#ERC6909-isOperator-address-address- +:xref-ERC6909-approve-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-approve-address-uint256-uint256- +:xref-ERC6909-setOperator-address-bool-: xref:token/ERC6909.adoc#ERC6909-setOperator-address-bool- +:xref-ERC6909-transfer-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transfer-address-uint256-uint256- +:xref-ERC6909-transferFrom-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transferFrom-address-address-uint256-uint256- +:xref-ERC6909-_mint-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_mint-address-uint256-uint256- +:xref-ERC6909-_transfer-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_transfer-address-address-uint256-uint256- +:xref-ERC6909-_burn-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_burn-address-uint256-uint256- +:xref-ERC6909-_update-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_update-address-address-uint256-uint256- +:xref-ERC6909-_approve-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_approve-address-address-uint256-uint256- +:xref-ERC6909-_setOperator-address-address-bool-: xref:token/ERC6909.adoc#ERC6909-_setOperator-address-address-bool- +:xref-ERC6909-_spendAllowance-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_spendAllowance-address-address-uint256-uint256- +:xref-ERC6909ContentURI-ContractURIUpdated--: xref:token/ERC6909.adoc#ERC6909ContentURI-ContractURIUpdated-- +:xref-ERC6909ContentURI-URI-string-uint256-: xref:token/ERC6909.adoc#ERC6909ContentURI-URI-string-uint256- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InvalidApprover-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidApprover-address- +:xref-ERC6909-ERC6909InvalidReceiver-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidReceiver-address- +:xref-ERC6909-ERC6909InvalidSender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSender-address- +:xref-ERC6909-ERC6909InvalidSpender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSpender-address- +:IERC1155-URI: pass:normal[xref:token/ERC1155.adoc#IERC1155-URI-string-uint256-[`IERC1155.URI`]] +:xref-ERC6909Metadata-name-uint256-: xref:token/ERC6909.adoc#ERC6909Metadata-name-uint256- +:xref-ERC6909Metadata-symbol-uint256-: xref:token/ERC6909.adoc#ERC6909Metadata-symbol-uint256- +:xref-ERC6909Metadata-decimals-uint256-: xref:token/ERC6909.adoc#ERC6909Metadata-decimals-uint256- +:xref-ERC6909Metadata-_setName-uint256-string-: xref:token/ERC6909.adoc#ERC6909Metadata-_setName-uint256-string- +:xref-ERC6909Metadata-_setSymbol-uint256-string-: xref:token/ERC6909.adoc#ERC6909Metadata-_setSymbol-uint256-string- +:xref-ERC6909Metadata-_setDecimals-uint256-uint8-: xref:token/ERC6909.adoc#ERC6909Metadata-_setDecimals-uint256-uint8- +:xref-ERC6909-supportsInterface-bytes4-: xref:token/ERC6909.adoc#ERC6909-supportsInterface-bytes4- +:xref-ERC6909-balanceOf-address-uint256-: xref:token/ERC6909.adoc#ERC6909-balanceOf-address-uint256- +:xref-ERC6909-allowance-address-address-uint256-: xref:token/ERC6909.adoc#ERC6909-allowance-address-address-uint256- +:xref-ERC6909-isOperator-address-address-: xref:token/ERC6909.adoc#ERC6909-isOperator-address-address- +:xref-ERC6909-approve-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-approve-address-uint256-uint256- +:xref-ERC6909-setOperator-address-bool-: xref:token/ERC6909.adoc#ERC6909-setOperator-address-bool- +:xref-ERC6909-transfer-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transfer-address-uint256-uint256- +:xref-ERC6909-transferFrom-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transferFrom-address-address-uint256-uint256- +:xref-ERC6909-_mint-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_mint-address-uint256-uint256- +:xref-ERC6909-_transfer-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_transfer-address-address-uint256-uint256- +:xref-ERC6909-_burn-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_burn-address-uint256-uint256- +:xref-ERC6909-_update-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_update-address-address-uint256-uint256- +:xref-ERC6909-_approve-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_approve-address-address-uint256-uint256- +:xref-ERC6909-_setOperator-address-address-bool-: xref:token/ERC6909.adoc#ERC6909-_setOperator-address-address-bool- +:xref-ERC6909-_spendAllowance-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_spendAllowance-address-address-uint256-uint256- +:xref-ERC6909Metadata-ERC6909NameUpdated-uint256-string-: xref:token/ERC6909.adoc#ERC6909Metadata-ERC6909NameUpdated-uint256-string- +:xref-ERC6909Metadata-ERC6909SymbolUpdated-uint256-string-: xref:token/ERC6909.adoc#ERC6909Metadata-ERC6909SymbolUpdated-uint256-string- +:xref-ERC6909Metadata-ERC6909DecimalsUpdated-uint256-uint8-: xref:token/ERC6909.adoc#ERC6909Metadata-ERC6909DecimalsUpdated-uint256-uint8- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InvalidApprover-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidApprover-address- +:xref-ERC6909-ERC6909InvalidReceiver-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidReceiver-address- +:xref-ERC6909-ERC6909InvalidSender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSender-address- +:xref-ERC6909-ERC6909InvalidSpender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSpender-address- +:xref-ERC6909TokenSupply-totalSupply-uint256-: xref:token/ERC6909.adoc#ERC6909TokenSupply-totalSupply-uint256- +:xref-ERC6909TokenSupply-_update-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909TokenSupply-_update-address-address-uint256-uint256- +:xref-ERC6909-supportsInterface-bytes4-: xref:token/ERC6909.adoc#ERC6909-supportsInterface-bytes4- +:xref-ERC6909-balanceOf-address-uint256-: xref:token/ERC6909.adoc#ERC6909-balanceOf-address-uint256- +:xref-ERC6909-allowance-address-address-uint256-: xref:token/ERC6909.adoc#ERC6909-allowance-address-address-uint256- +:xref-ERC6909-isOperator-address-address-: xref:token/ERC6909.adoc#ERC6909-isOperator-address-address- +:xref-ERC6909-approve-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-approve-address-uint256-uint256- +:xref-ERC6909-setOperator-address-bool-: xref:token/ERC6909.adoc#ERC6909-setOperator-address-bool- +:xref-ERC6909-transfer-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transfer-address-uint256-uint256- +:xref-ERC6909-transferFrom-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-transferFrom-address-address-uint256-uint256- +:xref-ERC6909-_mint-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_mint-address-uint256-uint256- +:xref-ERC6909-_transfer-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_transfer-address-address-uint256-uint256- +:xref-ERC6909-_burn-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_burn-address-uint256-uint256- +:xref-ERC6909-_approve-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_approve-address-address-uint256-uint256- +:xref-ERC6909-_setOperator-address-address-bool-: xref:token/ERC6909.adoc#ERC6909-_setOperator-address-address-bool- +:xref-ERC6909-_spendAllowance-address-address-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-_spendAllowance-address-address-uint256-uint256- +:xref-IERC6909-Approval-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Approval-address-address-uint256-uint256- +:xref-IERC6909-OperatorSet-address-address-bool-: xref:interfaces.adoc#IERC6909-OperatorSet-address-address-bool- +:xref-IERC6909-Transfer-address-address-address-uint256-uint256-: xref:interfaces.adoc#IERC6909-Transfer-address-address-address-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-: xref:token/ERC6909.adoc#ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256- +:xref-ERC6909-ERC6909InvalidApprover-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidApprover-address- +:xref-ERC6909-ERC6909InvalidReceiver-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidReceiver-address- +:xref-ERC6909-ERC6909InvalidSender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSender-address- +:xref-ERC6909-ERC6909InvalidSpender-address-: xref:token/ERC6909.adoc#ERC6909-ERC6909InvalidSpender-address- += ERC-6909 + +[.readme-notice] +NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/token/erc6909 + +This set of interfaces and contracts are all related to the https://eips.ethereum.org/EIPS/eip-6909[ERC-6909 Minimal Multi-Token Interface]. + +The ERC consists of four interfaces which fulfill different roles--the interfaces are as follows: + +. {IERC6909}: Base interface for a vanilla ERC6909 token. +. {IERC6909ContentURI}: Extends the base interface and adds content URI (contract and token level) functionality. +. {IERC6909Metadata}: Extends the base interface and adds metadata functionality, which exposes a name, symbol, and decimals for each token id. +. {IERC6909TokenSupply}: Extends the base interface and adds total supply functionality for each token id. + +Implementations are provided for each of the 4 interfaces defined in the ERC. + +== Core + +:ERC6909InsufficientBalance: pass:normal[xref:#ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-[`++ERC6909InsufficientBalance++`]] +:ERC6909InsufficientAllowance: pass:normal[xref:#ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-[`++ERC6909InsufficientAllowance++`]] +:ERC6909InvalidApprover: pass:normal[xref:#ERC6909-ERC6909InvalidApprover-address-[`++ERC6909InvalidApprover++`]] +:ERC6909InvalidReceiver: pass:normal[xref:#ERC6909-ERC6909InvalidReceiver-address-[`++ERC6909InvalidReceiver++`]] +:ERC6909InvalidSender: pass:normal[xref:#ERC6909-ERC6909InvalidSender-address-[`++ERC6909InvalidSender++`]] +:ERC6909InvalidSpender: pass:normal[xref:#ERC6909-ERC6909InvalidSpender-address-[`++ERC6909InvalidSpender++`]] +:supportsInterface: pass:normal[xref:#ERC6909-supportsInterface-bytes4-[`++supportsInterface++`]] +:balanceOf: pass:normal[xref:#ERC6909-balanceOf-address-uint256-[`++balanceOf++`]] +:allowance: pass:normal[xref:#ERC6909-allowance-address-address-uint256-[`++allowance++`]] +:isOperator: pass:normal[xref:#ERC6909-isOperator-address-address-[`++isOperator++`]] +:approve: pass:normal[xref:#ERC6909-approve-address-uint256-uint256-[`++approve++`]] +:setOperator: pass:normal[xref:#ERC6909-setOperator-address-bool-[`++setOperator++`]] +:transfer: pass:normal[xref:#ERC6909-transfer-address-uint256-uint256-[`++transfer++`]] +:transferFrom: pass:normal[xref:#ERC6909-transferFrom-address-address-uint256-uint256-[`++transferFrom++`]] +:_mint: pass:normal[xref:#ERC6909-_mint-address-uint256-uint256-[`++_mint++`]] +:_transfer: pass:normal[xref:#ERC6909-_transfer-address-address-uint256-uint256-[`++_transfer++`]] +:_burn: pass:normal[xref:#ERC6909-_burn-address-uint256-uint256-[`++_burn++`]] +:_update: pass:normal[xref:#ERC6909-_update-address-address-uint256-uint256-[`++_update++`]] +:_approve: pass:normal[xref:#ERC6909-_approve-address-address-uint256-uint256-[`++_approve++`]] +:_setOperator: pass:normal[xref:#ERC6909-_setOperator-address-address-bool-[`++_setOperator++`]] +:_spendAllowance: pass:normal[xref:#ERC6909-_spendAllowance-address-address-uint256-uint256-[`++_spendAllowance++`]] + +:supportsInterface-bytes4: pass:normal[xref:#ERC6909-supportsInterface-bytes4-[`++supportsInterface++`]] +:balanceOf-address-uint256: pass:normal[xref:#ERC6909-balanceOf-address-uint256-[`++balanceOf++`]] +:allowance-address-address-uint256: pass:normal[xref:#ERC6909-allowance-address-address-uint256-[`++allowance++`]] +:isOperator-address-address: pass:normal[xref:#ERC6909-isOperator-address-address-[`++isOperator++`]] +:approve-address-uint256-uint256: pass:normal[xref:#ERC6909-approve-address-uint256-uint256-[`++approve++`]] +:setOperator-address-bool: pass:normal[xref:#ERC6909-setOperator-address-bool-[`++setOperator++`]] +:transfer-address-uint256-uint256: pass:normal[xref:#ERC6909-transfer-address-uint256-uint256-[`++transfer++`]] +:transferFrom-address-address-uint256-uint256: pass:normal[xref:#ERC6909-transferFrom-address-address-uint256-uint256-[`++transferFrom++`]] +:_mint-address-uint256-uint256: pass:normal[xref:#ERC6909-_mint-address-uint256-uint256-[`++_mint++`]] +:_transfer-address-address-uint256-uint256: pass:normal[xref:#ERC6909-_transfer-address-address-uint256-uint256-[`++_transfer++`]] +:_burn-address-uint256-uint256: pass:normal[xref:#ERC6909-_burn-address-uint256-uint256-[`++_burn++`]] +:_update-address-address-uint256-uint256: pass:normal[xref:#ERC6909-_update-address-address-uint256-uint256-[`++_update++`]] +:_approve-address-address-uint256-uint256: pass:normal[xref:#ERC6909-_approve-address-address-uint256-uint256-[`++_approve++`]] +:_setOperator-address-address-bool: pass:normal[xref:#ERC6909-_setOperator-address-address-bool-[`++_setOperator++`]] +:_spendAllowance-address-address-uint256-uint256: pass:normal[xref:#ERC6909-_spendAllowance-address-address-uint256-uint256-[`++_spendAllowance++`]] + +[.contract] +[[ERC6909]] +=== `++ERC6909++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC6909/draft-ERC6909.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/token/ERC6909/draft-ERC6909.sol"; +``` + +Implementation of ERC-6909. +See https://eips.ethereum.org/EIPS/eip-6909 + +[.contract-index] +.Functions +-- +* {xref-ERC6909-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-ERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-ERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-ERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-ERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-ERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-ERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-ERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] +* {xref-ERC6909-_mint-address-uint256-uint256-}[`++_mint(to, id, amount)++`] +* {xref-ERC6909-_transfer-address-address-uint256-uint256-}[`++_transfer(from, to, id, amount)++`] +* {xref-ERC6909-_burn-address-uint256-uint256-}[`++_burn(from, id, amount)++`] +* {xref-ERC6909-_update-address-address-uint256-uint256-}[`++_update(from, to, id, amount)++`] +* {xref-ERC6909-_approve-address-address-uint256-uint256-}[`++_approve(owner, spender, id, amount)++`] +* {xref-ERC6909-_setOperator-address-address-bool-}[`++_setOperator(owner, spender, approved)++`] +* {xref-ERC6909-_spendAllowance-address-address-uint256-uint256-}[`++_spendAllowance(owner, spender, id, amount)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- +* {xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientBalance(sender, balance, needed, id)++`] +* {xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientAllowance(spender, allowance, needed, id)++`] +* {xref-ERC6909-ERC6909InvalidApprover-address-}[`++ERC6909InvalidApprover(approver)++`] +* {xref-ERC6909-ERC6909InvalidReceiver-address-}[`++ERC6909InvalidReceiver(receiver)++`] +* {xref-ERC6909-ERC6909InvalidSender-address-}[`++ERC6909InvalidSender(sender)++`] +* {xref-ERC6909-ERC6909InvalidSpender-address-}[`++ERC6909InvalidSpender(spender)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[ERC6909-supportsInterface-bytes4-]] +==== `[.contract-item-name]#++supportsInterface++#++(bytes4 interfaceId) → bool++` [.item-kind]#public# + +Returns true if this contract implements the interface defined by +`interfaceId`. See the corresponding +https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section] +to learn more about how these ids are created. + +This function call must use less than 30 000 gas. + +[.contract-item] +[[ERC6909-balanceOf-address-uint256-]] +==== `[.contract-item-name]#++balanceOf++#++(address owner, uint256 id) → uint256++` [.item-kind]#public# + +Returns the amount of tokens of type `id` owned by `owner`. + +[.contract-item] +[[ERC6909-allowance-address-address-uint256-]] +==== `[.contract-item-name]#++allowance++#++(address owner, address spender, uint256 id) → uint256++` [.item-kind]#public# + +Returns the amount of tokens of type `id` that `spender` is allowed to spend on behalf of `owner`. + +NOTE: Does not include operator allowances. + +[.contract-item] +[[ERC6909-isOperator-address-address-]] +==== `[.contract-item-name]#++isOperator++#++(address owner, address spender) → bool++` [.item-kind]#public# + +Returns true if `spender` is set as an operator for `owner`. + +[.contract-item] +[[ERC6909-approve-address-uint256-uint256-]] +==== `[.contract-item-name]#++approve++#++(address spender, uint256 id, uint256 amount) → bool++` [.item-kind]#public# + +Sets an approval to `spender` for `amount` of tokens of type `id` from the caller's tokens. An `amount` of +`type(uint256).max` signifies an unlimited approval. + +Must return true. + +[.contract-item] +[[ERC6909-setOperator-address-bool-]] +==== `[.contract-item-name]#++setOperator++#++(address spender, bool approved) → bool++` [.item-kind]#public# + +Grants or revokes unlimited transfer permission of any token id to `spender` for the caller's tokens. + +Must return true. + +[.contract-item] +[[ERC6909-transfer-address-uint256-uint256-]] +==== `[.contract-item-name]#++transfer++#++(address receiver, uint256 id, uint256 amount) → bool++` [.item-kind]#public# + +Transfers `amount` of token type `id` from the caller's account to `receiver`. + +Must return true. + +[.contract-item] +[[ERC6909-transferFrom-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++transferFrom++#++(address sender, address receiver, uint256 id, uint256 amount) → bool++` [.item-kind]#public# + +Transfers `amount` of token type `id` from `sender` to `receiver`. + +Must return true. + +[.contract-item] +[[ERC6909-_mint-address-uint256-uint256-]] +==== `[.contract-item-name]#++_mint++#++(address to, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Creates `amount` of token `id` and assigns them to `account`, by transferring it from address(0). +Relies on the `_update` mechanism. + +Emits a {Transfer} event with `from` set to the zero address. + +NOTE: This function is not virtual, {_update} should be overridden instead. + +[.contract-item] +[[ERC6909-_transfer-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++_transfer++#++(address from, address to, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Moves `amount` of token `id` from `from` to `to` without checking for approvals. This function verifies +that neither the sender nor the receiver are address(0), which means it cannot mint or burn tokens. +Relies on the `_update` mechanism. + +Emits a {Transfer} event. + +NOTE: This function is not virtual, {_update} should be overridden instead. + +[.contract-item] +[[ERC6909-_burn-address-uint256-uint256-]] +==== `[.contract-item-name]#++_burn++#++(address from, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Destroys a `amount` of token `id` from `account`. +Relies on the `_update` mechanism. + +Emits a {Transfer} event with `to` set to the zero address. + +NOTE: This function is not virtual, {_update} should be overridden instead + +[.contract-item] +[[ERC6909-_update-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++_update++#++(address from, address to, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Transfers `amount` of token `id` from `from` to `to`, or alternatively mints (or burns) if `from` +(or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding +this function. + +Emits a {Transfer} event. + +[.contract-item] +[[ERC6909-_approve-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++_approve++#++(address owner, address spender, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Sets `amount` as the allowance of `spender` over the `owner`'s `id` tokens. + +This internal function is equivalent to `approve`, and can be used to e.g. set automatic allowances for certain +subsystems, etc. + +Emits an {Approval} event. + +Requirements: + +- `owner` cannot be the zero address. +- `spender` cannot be the zero address. + +[.contract-item] +[[ERC6909-_setOperator-address-address-bool-]] +==== `[.contract-item-name]#++_setOperator++#++(address owner, address spender, bool approved)++` [.item-kind]#internal# + +Approve `spender` to operate on all of `owner`'s tokens + +This internal function is equivalent to `setOperator`, and can be used to e.g. set automatic allowances for +certain subsystems, etc. + +Emits an {OperatorSet} event. + +Requirements: + +- `owner` cannot be the zero address. +- `spender` cannot be the zero address. + +[.contract-item] +[[ERC6909-_spendAllowance-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++_spendAllowance++#++(address owner, address spender, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Updates `owner`'s allowance for `spender` based on spent `amount`. + +Does not update the allowance value in case of infinite allowance. +Revert if not enough allowance is available. + +Does not emit an {Approval} event. + +[.contract-item] +[[ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-]] +==== `[.contract-item-name]#++ERC6909InsufficientBalance++#++(address sender, uint256 balance, uint256 needed, uint256 id)++` [.item-kind]#error# + +[.contract-item] +[[ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-]] +==== `[.contract-item-name]#++ERC6909InsufficientAllowance++#++(address spender, uint256 allowance, uint256 needed, uint256 id)++` [.item-kind]#error# + +[.contract-item] +[[ERC6909-ERC6909InvalidApprover-address-]] +==== `[.contract-item-name]#++ERC6909InvalidApprover++#++(address approver)++` [.item-kind]#error# + +[.contract-item] +[[ERC6909-ERC6909InvalidReceiver-address-]] +==== `[.contract-item-name]#++ERC6909InvalidReceiver++#++(address receiver)++` [.item-kind]#error# + +[.contract-item] +[[ERC6909-ERC6909InvalidSender-address-]] +==== `[.contract-item-name]#++ERC6909InvalidSender++#++(address sender)++` [.item-kind]#error# + +[.contract-item] +[[ERC6909-ERC6909InvalidSpender-address-]] +==== `[.contract-item-name]#++ERC6909InvalidSpender++#++(address spender)++` [.item-kind]#error# + +== Extensions + +:ContractURIUpdated: pass:normal[xref:#ERC6909ContentURI-ContractURIUpdated--[`++ContractURIUpdated++`]] +:URI: pass:normal[xref:#ERC6909ContentURI-URI-string-uint256-[`++URI++`]] +:contractURI: pass:normal[xref:#ERC6909ContentURI-contractURI--[`++contractURI++`]] +:tokenURI: pass:normal[xref:#ERC6909ContentURI-tokenURI-uint256-[`++tokenURI++`]] +:_setContractURI: pass:normal[xref:#ERC6909ContentURI-_setContractURI-string-[`++_setContractURI++`]] +:_setTokenURI: pass:normal[xref:#ERC6909ContentURI-_setTokenURI-uint256-string-[`++_setTokenURI++`]] + +:contractURI-: pass:normal[xref:#ERC6909ContentURI-contractURI--[`++contractURI++`]] +:tokenURI-uint256: pass:normal[xref:#ERC6909ContentURI-tokenURI-uint256-[`++tokenURI++`]] +:_setContractURI-string: pass:normal[xref:#ERC6909ContentURI-_setContractURI-string-[`++_setContractURI++`]] +:_setTokenURI-uint256-string: pass:normal[xref:#ERC6909ContentURI-_setTokenURI-uint256-string-[`++_setTokenURI++`]] + +[.contract] +[[ERC6909ContentURI]] +=== `++ERC6909ContentURI++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC6909/extensions/draft-ERC6909ContentURI.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/token/ERC6909/extensions/draft-ERC6909ContentURI.sol"; +``` + +Implementation of the Content URI extension defined in ERC6909. + +[.contract-index] +.Functions +-- +* {xref-ERC6909ContentURI-contractURI--}[`++contractURI()++`] +* {xref-ERC6909ContentURI-tokenURI-uint256-}[`++tokenURI(id)++`] +* {xref-ERC6909ContentURI-_setContractURI-string-}[`++_setContractURI(newContractURI)++`] +* {xref-ERC6909ContentURI-_setTokenURI-uint256-string-}[`++_setTokenURI(id, newTokenURI)++`] + +[.contract-subindex-inherited] +.IERC6909ContentURI + +[.contract-subindex-inherited] +.ERC6909 +* {xref-ERC6909-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-ERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-ERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-ERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-ERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-ERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-ERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-ERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] +* {xref-ERC6909-_mint-address-uint256-uint256-}[`++_mint(to, id, amount)++`] +* {xref-ERC6909-_transfer-address-address-uint256-uint256-}[`++_transfer(from, to, id, amount)++`] +* {xref-ERC6909-_burn-address-uint256-uint256-}[`++_burn(from, id, amount)++`] +* {xref-ERC6909-_update-address-address-uint256-uint256-}[`++_update(from, to, id, amount)++`] +* {xref-ERC6909-_approve-address-address-uint256-uint256-}[`++_approve(owner, spender, id, amount)++`] +* {xref-ERC6909-_setOperator-address-address-bool-}[`++_setOperator(owner, spender, approved)++`] +* {xref-ERC6909-_spendAllowance-address-address-uint256-uint256-}[`++_spendAllowance(owner, spender, id, amount)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- +* {xref-ERC6909ContentURI-ContractURIUpdated--}[`++ContractURIUpdated()++`] +* {xref-ERC6909ContentURI-URI-string-uint256-}[`++URI(value, id)++`] + +[.contract-subindex-inherited] +.IERC6909ContentURI + +[.contract-subindex-inherited] +.ERC6909 + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- + +[.contract-subindex-inherited] +.IERC6909ContentURI + +[.contract-subindex-inherited] +.ERC6909 +* {xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientBalance(sender, balance, needed, id)++`] +* {xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientAllowance(spender, allowance, needed, id)++`] +* {xref-ERC6909-ERC6909InvalidApprover-address-}[`++ERC6909InvalidApprover(approver)++`] +* {xref-ERC6909-ERC6909InvalidReceiver-address-}[`++ERC6909InvalidReceiver(receiver)++`] +* {xref-ERC6909-ERC6909InvalidSender-address-}[`++ERC6909InvalidSender(sender)++`] +* {xref-ERC6909-ERC6909InvalidSpender-address-}[`++ERC6909InvalidSpender(spender)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[ERC6909ContentURI-contractURI--]] +==== `[.contract-item-name]#++contractURI++#++() → string++` [.item-kind]#public# + +Returns URI for the contract. + +[.contract-item] +[[ERC6909ContentURI-tokenURI-uint256-]] +==== `[.contract-item-name]#++tokenURI++#++(uint256 id) → string++` [.item-kind]#public# + +Returns the URI for the token of type `id`. + +[.contract-item] +[[ERC6909ContentURI-_setContractURI-string-]] +==== `[.contract-item-name]#++_setContractURI++#++(string newContractURI)++` [.item-kind]#internal# + +Sets the {contractURI} for the contract. + +Emits a {ContractURIUpdated} event. + +[.contract-item] +[[ERC6909ContentURI-_setTokenURI-uint256-string-]] +==== `[.contract-item-name]#++_setTokenURI++#++(uint256 id, string newTokenURI)++` [.item-kind]#internal# + +Sets the {tokenURI} for a given token of type `id`. + +Emits a {URI} event. + +[.contract-item] +[[ERC6909ContentURI-ContractURIUpdated--]] +==== `[.contract-item-name]#++ContractURIUpdated++#++()++` [.item-kind]#event# + +Event emitted when the contract URI is changed. See https://eips.ethereum.org/EIPS/eip-7572[ERC-7572] for details. + +[.contract-item] +[[ERC6909ContentURI-URI-string-uint256-]] +==== `[.contract-item-name]#++URI++#++(string value, uint256 indexed id)++` [.item-kind]#event# + +See {IERC1155-URI} + +:TokenMetadata: pass:normal[xref:#ERC6909Metadata-TokenMetadata[`++TokenMetadata++`]] +:ERC6909NameUpdated: pass:normal[xref:#ERC6909Metadata-ERC6909NameUpdated-uint256-string-[`++ERC6909NameUpdated++`]] +:ERC6909SymbolUpdated: pass:normal[xref:#ERC6909Metadata-ERC6909SymbolUpdated-uint256-string-[`++ERC6909SymbolUpdated++`]] +:ERC6909DecimalsUpdated: pass:normal[xref:#ERC6909Metadata-ERC6909DecimalsUpdated-uint256-uint8-[`++ERC6909DecimalsUpdated++`]] +:name: pass:normal[xref:#ERC6909Metadata-name-uint256-[`++name++`]] +:symbol: pass:normal[xref:#ERC6909Metadata-symbol-uint256-[`++symbol++`]] +:decimals: pass:normal[xref:#ERC6909Metadata-decimals-uint256-[`++decimals++`]] +:_setName: pass:normal[xref:#ERC6909Metadata-_setName-uint256-string-[`++_setName++`]] +:_setSymbol: pass:normal[xref:#ERC6909Metadata-_setSymbol-uint256-string-[`++_setSymbol++`]] +:_setDecimals: pass:normal[xref:#ERC6909Metadata-_setDecimals-uint256-uint8-[`++_setDecimals++`]] + +:name-uint256: pass:normal[xref:#ERC6909Metadata-name-uint256-[`++name++`]] +:symbol-uint256: pass:normal[xref:#ERC6909Metadata-symbol-uint256-[`++symbol++`]] +:decimals-uint256: pass:normal[xref:#ERC6909Metadata-decimals-uint256-[`++decimals++`]] +:_setName-uint256-string: pass:normal[xref:#ERC6909Metadata-_setName-uint256-string-[`++_setName++`]] +:_setSymbol-uint256-string: pass:normal[xref:#ERC6909Metadata-_setSymbol-uint256-string-[`++_setSymbol++`]] +:_setDecimals-uint256-uint8: pass:normal[xref:#ERC6909Metadata-_setDecimals-uint256-uint8-[`++_setDecimals++`]] + +[.contract] +[[ERC6909Metadata]] +=== `++ERC6909Metadata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/token/ERC6909/extensions/draft-ERC6909Metadata.sol"; +``` + +Implementation of the Metadata extension defined in ERC6909. Exposes the name, symbol, and decimals of each token id. + +[.contract-index] +.Functions +-- +* {xref-ERC6909Metadata-name-uint256-}[`++name(id)++`] +* {xref-ERC6909Metadata-symbol-uint256-}[`++symbol(id)++`] +* {xref-ERC6909Metadata-decimals-uint256-}[`++decimals(id)++`] +* {xref-ERC6909Metadata-_setName-uint256-string-}[`++_setName(id, newName)++`] +* {xref-ERC6909Metadata-_setSymbol-uint256-string-}[`++_setSymbol(id, newSymbol)++`] +* {xref-ERC6909Metadata-_setDecimals-uint256-uint8-}[`++_setDecimals(id, newDecimals)++`] + +[.contract-subindex-inherited] +.IERC6909Metadata + +[.contract-subindex-inherited] +.ERC6909 +* {xref-ERC6909-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-ERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-ERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-ERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-ERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-ERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-ERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-ERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] +* {xref-ERC6909-_mint-address-uint256-uint256-}[`++_mint(to, id, amount)++`] +* {xref-ERC6909-_transfer-address-address-uint256-uint256-}[`++_transfer(from, to, id, amount)++`] +* {xref-ERC6909-_burn-address-uint256-uint256-}[`++_burn(from, id, amount)++`] +* {xref-ERC6909-_update-address-address-uint256-uint256-}[`++_update(from, to, id, amount)++`] +* {xref-ERC6909-_approve-address-address-uint256-uint256-}[`++_approve(owner, spender, id, amount)++`] +* {xref-ERC6909-_setOperator-address-address-bool-}[`++_setOperator(owner, spender, approved)++`] +* {xref-ERC6909-_spendAllowance-address-address-uint256-uint256-}[`++_spendAllowance(owner, spender, id, amount)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- +* {xref-ERC6909Metadata-ERC6909NameUpdated-uint256-string-}[`++ERC6909NameUpdated(id, newName)++`] +* {xref-ERC6909Metadata-ERC6909SymbolUpdated-uint256-string-}[`++ERC6909SymbolUpdated(id, newSymbol)++`] +* {xref-ERC6909Metadata-ERC6909DecimalsUpdated-uint256-uint8-}[`++ERC6909DecimalsUpdated(id, newDecimals)++`] + +[.contract-subindex-inherited] +.IERC6909Metadata + +[.contract-subindex-inherited] +.ERC6909 + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- + +[.contract-subindex-inherited] +.IERC6909Metadata + +[.contract-subindex-inherited] +.ERC6909 +* {xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientBalance(sender, balance, needed, id)++`] +* {xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientAllowance(spender, allowance, needed, id)++`] +* {xref-ERC6909-ERC6909InvalidApprover-address-}[`++ERC6909InvalidApprover(approver)++`] +* {xref-ERC6909-ERC6909InvalidReceiver-address-}[`++ERC6909InvalidReceiver(receiver)++`] +* {xref-ERC6909-ERC6909InvalidSender-address-}[`++ERC6909InvalidSender(sender)++`] +* {xref-ERC6909-ERC6909InvalidSpender-address-}[`++ERC6909InvalidSpender(spender)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[ERC6909Metadata-name-uint256-]] +==== `[.contract-item-name]#++name++#++(uint256 id) → string++` [.item-kind]#public# + +Returns the name of the token of type `id`. + +[.contract-item] +[[ERC6909Metadata-symbol-uint256-]] +==== `[.contract-item-name]#++symbol++#++(uint256 id) → string++` [.item-kind]#public# + +Returns the ticker symbol of the token of type `id`. + +[.contract-item] +[[ERC6909Metadata-decimals-uint256-]] +==== `[.contract-item-name]#++decimals++#++(uint256 id) → uint8++` [.item-kind]#public# + +Returns the number of decimals for the token of type `id`. + +[.contract-item] +[[ERC6909Metadata-_setName-uint256-string-]] +==== `[.contract-item-name]#++_setName++#++(uint256 id, string newName)++` [.item-kind]#internal# + +Sets the `name` for a given token of type `id`. + +Emits an {ERC6909NameUpdated} event. + +[.contract-item] +[[ERC6909Metadata-_setSymbol-uint256-string-]] +==== `[.contract-item-name]#++_setSymbol++#++(uint256 id, string newSymbol)++` [.item-kind]#internal# + +Sets the `symbol` for a given token of type `id`. + +Emits an {ERC6909SymbolUpdated} event. + +[.contract-item] +[[ERC6909Metadata-_setDecimals-uint256-uint8-]] +==== `[.contract-item-name]#++_setDecimals++#++(uint256 id, uint8 newDecimals)++` [.item-kind]#internal# + +Sets the `decimals` for a given token of type `id`. + +Emits an {ERC6909DecimalsUpdated} event. + +[.contract-item] +[[ERC6909Metadata-ERC6909NameUpdated-uint256-string-]] +==== `[.contract-item-name]#++ERC6909NameUpdated++#++(uint256 indexed id, string newName)++` [.item-kind]#event# + +The name of the token of type `id` was updated to `newName`. + +[.contract-item] +[[ERC6909Metadata-ERC6909SymbolUpdated-uint256-string-]] +==== `[.contract-item-name]#++ERC6909SymbolUpdated++#++(uint256 indexed id, string newSymbol)++` [.item-kind]#event# + +The symbol for the token of type `id` was updated to `newSymbol`. + +[.contract-item] +[[ERC6909Metadata-ERC6909DecimalsUpdated-uint256-uint8-]] +==== `[.contract-item-name]#++ERC6909DecimalsUpdated++#++(uint256 indexed id, uint8 newDecimals)++` [.item-kind]#event# + +The decimals value for token of type `id` was updated to `newDecimals`. + +:totalSupply: pass:normal[xref:#ERC6909TokenSupply-totalSupply-uint256-[`++totalSupply++`]] +:_update: pass:normal[xref:#ERC6909TokenSupply-_update-address-address-uint256-uint256-[`++_update++`]] + +:totalSupply-uint256: pass:normal[xref:#ERC6909TokenSupply-totalSupply-uint256-[`++totalSupply++`]] +:_update-address-address-uint256-uint256: pass:normal[xref:#ERC6909TokenSupply-_update-address-address-uint256-uint256-[`++_update++`]] + +[.contract] +[[ERC6909TokenSupply]] +=== `++ERC6909TokenSupply++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC6909/extensions/draft-ERC6909TokenSupply.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/token/ERC6909/extensions/draft-ERC6909TokenSupply.sol"; +``` + +Implementation of the Token Supply extension defined in ERC6909. +Tracks the total supply of each token id individually. + +[.contract-index] +.Functions +-- +* {xref-ERC6909TokenSupply-totalSupply-uint256-}[`++totalSupply(id)++`] +* {xref-ERC6909TokenSupply-_update-address-address-uint256-uint256-}[`++_update(from, to, id, amount)++`] + +[.contract-subindex-inherited] +.IERC6909TokenSupply + +[.contract-subindex-inherited] +.ERC6909 +* {xref-ERC6909-supportsInterface-bytes4-}[`++supportsInterface(interfaceId)++`] +* {xref-ERC6909-balanceOf-address-uint256-}[`++balanceOf(owner, id)++`] +* {xref-ERC6909-allowance-address-address-uint256-}[`++allowance(owner, spender, id)++`] +* {xref-ERC6909-isOperator-address-address-}[`++isOperator(owner, spender)++`] +* {xref-ERC6909-approve-address-uint256-uint256-}[`++approve(spender, id, amount)++`] +* {xref-ERC6909-setOperator-address-bool-}[`++setOperator(spender, approved)++`] +* {xref-ERC6909-transfer-address-uint256-uint256-}[`++transfer(receiver, id, amount)++`] +* {xref-ERC6909-transferFrom-address-address-uint256-uint256-}[`++transferFrom(sender, receiver, id, amount)++`] +* {xref-ERC6909-_mint-address-uint256-uint256-}[`++_mint(to, id, amount)++`] +* {xref-ERC6909-_transfer-address-address-uint256-uint256-}[`++_transfer(from, to, id, amount)++`] +* {xref-ERC6909-_burn-address-uint256-uint256-}[`++_burn(from, id, amount)++`] +* {xref-ERC6909-_approve-address-address-uint256-uint256-}[`++_approve(owner, spender, id, amount)++`] +* {xref-ERC6909-_setOperator-address-address-bool-}[`++_setOperator(owner, spender, approved)++`] +* {xref-ERC6909-_spendAllowance-address-address-uint256-uint256-}[`++_spendAllowance(owner, spender, id, amount)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Events +-- + +[.contract-subindex-inherited] +.IERC6909TokenSupply + +[.contract-subindex-inherited] +.ERC6909 + +[.contract-subindex-inherited] +.IERC6909 +* {xref-IERC6909-Approval-address-address-uint256-uint256-}[`++Approval(owner, spender, id, amount)++`] +* {xref-IERC6909-OperatorSet-address-address-bool-}[`++OperatorSet(owner, spender, approved)++`] +* {xref-IERC6909-Transfer-address-address-address-uint256-uint256-}[`++Transfer(caller, sender, receiver, id, amount)++`] + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-index] +.Errors +-- + +[.contract-subindex-inherited] +.IERC6909TokenSupply + +[.contract-subindex-inherited] +.ERC6909 +* {xref-ERC6909-ERC6909InsufficientBalance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientBalance(sender, balance, needed, id)++`] +* {xref-ERC6909-ERC6909InsufficientAllowance-address-uint256-uint256-uint256-}[`++ERC6909InsufficientAllowance(spender, allowance, needed, id)++`] +* {xref-ERC6909-ERC6909InvalidApprover-address-}[`++ERC6909InvalidApprover(approver)++`] +* {xref-ERC6909-ERC6909InvalidReceiver-address-}[`++ERC6909InvalidReceiver(receiver)++`] +* {xref-ERC6909-ERC6909InvalidSender-address-}[`++ERC6909InvalidSender(sender)++`] +* {xref-ERC6909-ERC6909InvalidSpender-address-}[`++ERC6909InvalidSpender(spender)++`] + +[.contract-subindex-inherited] +.IERC6909 + +[.contract-subindex-inherited] +.ERC165 + +[.contract-subindex-inherited] +.IERC165 + +-- + +[.contract-item] +[[ERC6909TokenSupply-totalSupply-uint256-]] +==== `[.contract-item-name]#++totalSupply++#++(uint256 id) → uint256++` [.item-kind]#public# + +Returns the total supply of the token of type `id`. + +[.contract-item] +[[ERC6909TokenSupply-_update-address-address-uint256-uint256-]] +==== `[.contract-item-name]#++_update++#++(address from, address to, uint256 id, uint256 amount)++` [.item-kind]#internal# + +Override the `_update` function to update the total supply of each token id as necessary. + diff --git a/docs/modules/api/pages/token/ERC721.adoc b/docs/modules/api/pages/token/ERC721.adoc index 10cf72827..c2b365f07 100644 --- a/docs/modules/api/pages/token/ERC721.adoc +++ b/docs/modules/api/pages/token/ERC721.adoc @@ -386,6 +386,7 @@ :xref-IERC721Errors-ERC721InvalidOperator-address-: xref:interfaces.adoc#IERC721Errors-ERC721InvalidOperator-address- :IERC165-supportsInterface: pass:normal[xref:utils.adoc#IERC165-supportsInterface-bytes4-[`IERC165.supportsInterface`]] :IERC721Metadata-tokenURI: pass:normal[xref:token/ERC721.adoc#IERC721Metadata-tokenURI-uint256-[`IERC721Metadata.tokenURI`]] +:IERC4906-MetadataUpdate: pass:normal[xref:interfaces.adoc#IERC4906-MetadataUpdate-uint256-[`IERC4906.MetadataUpdate`]] :Votes: pass:normal[xref:governance.adoc#Votes[`Votes`]] :xref-ERC721Votes-_update-address-uint256-address-: xref:token/ERC721.adoc#ERC721Votes-_update-address-uint256-address- :xref-ERC721Votes-_getVotingUnits-address-: xref:token/ERC721.adoc#ERC721Votes-_getVotingUnits-address- @@ -579,12 +580,13 @@ :IERC721Receiver-onERC721Received: pass:normal[xref:token/ERC721.adoc#IERC721Receiver-onERC721Received-address-address-uint256-bytes-[`IERC721Receiver.onERC721Received`]] :xref-ERC721Utils-checkOnERC721Received-address-address-address-uint256-bytes-: xref:token/ERC721.adoc#ERC721Utils-checkOnERC721Received-address-address-address-uint256-bytes- :IERC721Receiver-onERC721Received: pass:normal[xref:token/ERC721.adoc#IERC721Receiver-onERC721Received-address-address-uint256-bytes-[`IERC721Receiver.onERC721Received`]] +:IERC721Receiver-onERC721Received: pass:normal[xref:token/ERC721.adoc#IERC721Receiver-onERC721Received-address-address-uint256-bytes-[`IERC721Receiver.onERC721Received`]] = ERC-721 [.readme-notice] NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/token/erc721 -This set of interfaces, contracts, and utilities are all related to the https://eips.ethereum.org/EIPS/eip-721[ERC-721 Non-Fungible Token Standard]. +This set of interfaces, contracts, and utilities is all related to the https://eips.ethereum.org/EIPS/eip-721[ERC-721 Non-Fungible Token Standard]. TIP: For a walk through on how to create an ERC-721 token read our xref:ROOT:erc721.adoc[ERC-721 guide]. @@ -603,7 +605,7 @@ OpenZeppelin Contracts provides implementations of all four interfaces: Additionally there are a few of other extensions: -* {ERC721Consecutive}: An implementation of https://eips.ethereum.org/EIPS/eip-2309[ERC-2309] for minting batchs of tokens during construction, in accordance with ERC-721. +* {ERC721Consecutive}: An implementation of https://eips.ethereum.org/EIPS/eip-2309[ERC-2309] for minting batches of tokens during construction, in accordance with ERC-721. * {ERC721URIStorage}: A more flexible but more expensive way of storing metadata. * {ERC721Votes}: Support for voting and vote delegation. * {ERC721Royalty}: A way to signal royalty information following ERC-2981. @@ -628,9 +630,19 @@ NOTE: This core set of contracts is designed to be unopinionated, allowing devel :getApproved: pass:normal[xref:#IERC721-getApproved-uint256-[`++getApproved++`]] :isApprovedForAll: pass:normal[xref:#IERC721-isApprovedForAll-address-address-[`++isApprovedForAll++`]] +:balanceOf-address: pass:normal[xref:#IERC721-balanceOf-address-[`++balanceOf++`]] +:ownerOf-uint256: pass:normal[xref:#IERC721-ownerOf-uint256-[`++ownerOf++`]] +:safeTransferFrom-address-address-uint256-bytes: pass:normal[xref:#IERC721-safeTransferFrom-address-address-uint256-bytes-[`++safeTransferFrom++`]] +:safeTransferFrom-address-address-uint256: pass:normal[xref:#IERC721-safeTransferFrom-address-address-uint256-[`++safeTransferFrom++`]] +:transferFrom-address-address-uint256: pass:normal[xref:#IERC721-transferFrom-address-address-uint256-[`++transferFrom++`]] +:approve-address-uint256: pass:normal[xref:#IERC721-approve-address-uint256-[`++approve++`]] +:setApprovalForAll-address-bool: pass:normal[xref:#IERC721-setApprovalForAll-address-bool-[`++setApprovalForAll++`]] +:getApproved-uint256: pass:normal[xref:#IERC721-getApproved-uint256-[`++getApproved++`]] +:isApprovedForAll-address-address: pass:normal[xref:#IERC721-isApprovedForAll-address-address-[`++isApprovedForAll++`]] + [.contract] [[IERC721]] -=== `++IERC721++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/IERC721.sol[{github-icon},role=heading-link] +=== `++IERC721++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/IERC721.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -810,9 +822,13 @@ Emitted when `owner` enables or disables (`approved`) `operator` to manage all o :symbol: pass:normal[xref:#IERC721Metadata-symbol--[`++symbol++`]] :tokenURI: pass:normal[xref:#IERC721Metadata-tokenURI-uint256-[`++tokenURI++`]] +:name-: pass:normal[xref:#IERC721Metadata-name--[`++name++`]] +:symbol-: pass:normal[xref:#IERC721Metadata-symbol--[`++symbol++`]] +:tokenURI-uint256: pass:normal[xref:#IERC721Metadata-tokenURI-uint256-[`++tokenURI++`]] + [.contract] [[IERC721Metadata]] -=== `++IERC721Metadata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/IERC721Metadata.sol[{github-icon},role=heading-link] +=== `++IERC721Metadata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/IERC721Metadata.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -883,9 +899,13 @@ Returns the Uniform Resource Identifier (URI) for `tokenId` token. :tokenOfOwnerByIndex: pass:normal[xref:#IERC721Enumerable-tokenOfOwnerByIndex-address-uint256-[`++tokenOfOwnerByIndex++`]] :tokenByIndex: pass:normal[xref:#IERC721Enumerable-tokenByIndex-uint256-[`++tokenByIndex++`]] +:totalSupply-: pass:normal[xref:#IERC721Enumerable-totalSupply--[`++totalSupply++`]] +:tokenOfOwnerByIndex-address-uint256: pass:normal[xref:#IERC721Enumerable-tokenOfOwnerByIndex-address-uint256-[`++tokenOfOwnerByIndex++`]] +:tokenByIndex-uint256: pass:normal[xref:#IERC721Enumerable-tokenByIndex-uint256-[`++tokenByIndex++`]] + [.contract] [[IERC721Enumerable]] -=== `++IERC721Enumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/IERC721Enumerable.sol[{github-icon},role=heading-link] +=== `++IERC721Enumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/IERC721Enumerable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -987,9 +1007,42 @@ Use along with {totalSupply} to enumerate all tokens. :_setApprovalForAll: pass:normal[xref:#ERC721-_setApprovalForAll-address-address-bool-[`++_setApprovalForAll++`]] :_requireOwned: pass:normal[xref:#ERC721-_requireOwned-uint256-[`++_requireOwned++`]] +:constructor-string-string: pass:normal[xref:#ERC721-constructor-string-string-[`++constructor++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC721-supportsInterface-bytes4-[`++supportsInterface++`]] +:balanceOf-address: pass:normal[xref:#ERC721-balanceOf-address-[`++balanceOf++`]] +:ownerOf-uint256: pass:normal[xref:#ERC721-ownerOf-uint256-[`++ownerOf++`]] +:name-: pass:normal[xref:#ERC721-name--[`++name++`]] +:symbol-: pass:normal[xref:#ERC721-symbol--[`++symbol++`]] +:tokenURI-uint256: pass:normal[xref:#ERC721-tokenURI-uint256-[`++tokenURI++`]] +:_baseURI-: pass:normal[xref:#ERC721-_baseURI--[`++_baseURI++`]] +:approve-address-uint256: pass:normal[xref:#ERC721-approve-address-uint256-[`++approve++`]] +:getApproved-uint256: pass:normal[xref:#ERC721-getApproved-uint256-[`++getApproved++`]] +:setApprovalForAll-address-bool: pass:normal[xref:#ERC721-setApprovalForAll-address-bool-[`++setApprovalForAll++`]] +:isApprovedForAll-address-address: pass:normal[xref:#ERC721-isApprovedForAll-address-address-[`++isApprovedForAll++`]] +:transferFrom-address-address-uint256: pass:normal[xref:#ERC721-transferFrom-address-address-uint256-[`++transferFrom++`]] +:safeTransferFrom-address-address-uint256: pass:normal[xref:#ERC721-safeTransferFrom-address-address-uint256-[`++safeTransferFrom++`]] +:safeTransferFrom-address-address-uint256-bytes: pass:normal[xref:#ERC721-safeTransferFrom-address-address-uint256-bytes-[`++safeTransferFrom++`]] +:_ownerOf-uint256: pass:normal[xref:#ERC721-_ownerOf-uint256-[`++_ownerOf++`]] +:_getApproved-uint256: pass:normal[xref:#ERC721-_getApproved-uint256-[`++_getApproved++`]] +:_isAuthorized-address-address-uint256: pass:normal[xref:#ERC721-_isAuthorized-address-address-uint256-[`++_isAuthorized++`]] +:_checkAuthorized-address-address-uint256: pass:normal[xref:#ERC721-_checkAuthorized-address-address-uint256-[`++_checkAuthorized++`]] +:_increaseBalance-address-uint128: pass:normal[xref:#ERC721-_increaseBalance-address-uint128-[`++_increaseBalance++`]] +:_update-address-uint256-address: pass:normal[xref:#ERC721-_update-address-uint256-address-[`++_update++`]] +:_mint-address-uint256: pass:normal[xref:#ERC721-_mint-address-uint256-[`++_mint++`]] +:_safeMint-address-uint256: pass:normal[xref:#ERC721-_safeMint-address-uint256-[`++_safeMint++`]] +:_safeMint-address-uint256-bytes: pass:normal[xref:#ERC721-_safeMint-address-uint256-bytes-[`++_safeMint++`]] +:_burn-uint256: pass:normal[xref:#ERC721-_burn-uint256-[`++_burn++`]] +:_transfer-address-address-uint256: pass:normal[xref:#ERC721-_transfer-address-address-uint256-[`++_transfer++`]] +:_safeTransfer-address-address-uint256: pass:normal[xref:#ERC721-_safeTransfer-address-address-uint256-[`++_safeTransfer++`]] +:_safeTransfer-address-address-uint256-bytes: pass:normal[xref:#ERC721-_safeTransfer-address-address-uint256-bytes-[`++_safeTransfer++`]] +:_approve-address-uint256-address: pass:normal[xref:#ERC721-_approve-address-uint256-address-[`++_approve++`]] +:_approve-address-uint256-address-bool: pass:normal[xref:#ERC721-_approve-address-uint256-address-bool-[`++_approve++`]] +:_setApprovalForAll-address-address-bool: pass:normal[xref:#ERC721-_setApprovalForAll-address-address-bool-[`++_setApprovalForAll++`]] +:_requireOwned-uint256: pass:normal[xref:#ERC721-_requireOwned-uint256-[`++_requireOwned++`]] + [.contract] [[ERC721]] -=== `++ERC721++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/ERC721.sol[{github-icon},role=heading-link] +=== `++ERC721++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/ERC721.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1405,9 +1458,16 @@ Overrides to ownership logic should be done to {_ownerOf}. :_update: pass:normal[xref:#ERC721Enumerable-_update-address-uint256-address-[`++_update++`]] :_increaseBalance: pass:normal[xref:#ERC721Enumerable-_increaseBalance-address-uint128-[`++_increaseBalance++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC721Enumerable-supportsInterface-bytes4-[`++supportsInterface++`]] +:tokenOfOwnerByIndex-address-uint256: pass:normal[xref:#ERC721Enumerable-tokenOfOwnerByIndex-address-uint256-[`++tokenOfOwnerByIndex++`]] +:totalSupply-: pass:normal[xref:#ERC721Enumerable-totalSupply--[`++totalSupply++`]] +:tokenByIndex-uint256: pass:normal[xref:#ERC721Enumerable-tokenByIndex-uint256-[`++tokenByIndex++`]] +:_update-address-uint256-address: pass:normal[xref:#ERC721Enumerable-_update-address-uint256-address-[`++_update++`]] +:_increaseBalance-address-uint128: pass:normal[xref:#ERC721Enumerable-_increaseBalance-address-uint128-[`++_increaseBalance++`]] + [.contract] [[ERC721Enumerable]] -=== `++ERC721Enumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Enumerable.sol[{github-icon},role=heading-link] +=== `++ERC721Enumerable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Enumerable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1598,9 +1658,11 @@ Batch mint is not allowed. :onERC721Received: pass:normal[xref:#IERC721Receiver-onERC721Received-address-address-uint256-bytes-[`++onERC721Received++`]] +:onERC721Received-address-address-uint256-bytes: pass:normal[xref:#IERC721Receiver-onERC721Received-address-address-uint256-bytes-[`++onERC721Received++`]] + [.contract] [[IERC721Receiver]] -=== `++IERC721Receiver++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/IERC721Receiver.sol[{github-icon},role=heading-link] +=== `++IERC721Receiver++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/IERC721Receiver.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1634,9 +1696,11 @@ The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received. :_update: pass:normal[xref:#ERC721Pausable-_update-address-uint256-address-[`++_update++`]] +:_update-address-uint256-address: pass:normal[xref:#ERC721Pausable-_update-address-uint256-address-[`++_update++`]] + [.contract] [[ERC721Pausable]] -=== `++ERC721Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Pausable.sol[{github-icon},role=heading-link] +=== `++ERC721Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Pausable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1799,9 +1863,11 @@ Requirements: :burn: pass:normal[xref:#ERC721Burnable-burn-uint256-[`++burn++`]] +:burn-uint256: pass:normal[xref:#ERC721Burnable-burn-uint256-[`++burn++`]] + [.contract] [[ERC721Burnable]] -=== `++ERC721Burnable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Burnable.sol[{github-icon},role=heading-link] +=== `++ERC721Burnable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Burnable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1945,9 +2011,15 @@ Requirements: :_update: pass:normal[xref:#ERC721Consecutive-_update-address-uint256-address-[`++_update++`]] :_firstConsecutiveId: pass:normal[xref:#ERC721Consecutive-_firstConsecutiveId--[`++_firstConsecutiveId++`]] +:_maxBatchSize-: pass:normal[xref:#ERC721Consecutive-_maxBatchSize--[`++_maxBatchSize++`]] +:_ownerOf-uint256: pass:normal[xref:#ERC721Consecutive-_ownerOf-uint256-[`++_ownerOf++`]] +:_mintConsecutive-address-uint96: pass:normal[xref:#ERC721Consecutive-_mintConsecutive-address-uint96-[`++_mintConsecutive++`]] +:_update-address-uint256-address: pass:normal[xref:#ERC721Consecutive-_update-address-uint256-address-[`++_update++`]] +:_firstConsecutiveId-: pass:normal[xref:#ERC721Consecutive-_firstConsecutiveId--[`++_firstConsecutiveId++`]] + [.contract] [[ERC721Consecutive]] -=== `++ERC721Consecutive++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Consecutive.sol[{github-icon},role=heading-link] +=== `++ERC721Consecutive++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Consecutive.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2153,7 +2225,7 @@ After construction, {_mintConsecutive} is no longer available and minting throug [[ERC721Consecutive-_firstConsecutiveId--]] ==== `[.contract-item-name]#++_firstConsecutiveId++#++() → uint96++` [.item-kind]#internal# -Used to offset the first token id in {_nextConsecutiveId} +Used to offset the first token id in `_nextConsecutiveId` [.contract-item] [[ERC721Consecutive-ERC721ForbiddenBatchMint--]] @@ -2185,9 +2257,13 @@ Batch burn is not supported. :tokenURI: pass:normal[xref:#ERC721URIStorage-tokenURI-uint256-[`++tokenURI++`]] :_setTokenURI: pass:normal[xref:#ERC721URIStorage-_setTokenURI-uint256-string-[`++_setTokenURI++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC721URIStorage-supportsInterface-bytes4-[`++supportsInterface++`]] +:tokenURI-uint256: pass:normal[xref:#ERC721URIStorage-tokenURI-uint256-[`++tokenURI++`]] +:_setTokenURI-uint256-string: pass:normal[xref:#ERC721URIStorage-_setTokenURI-uint256-string-[`++_setTokenURI++`]] + [.contract] [[ERC721URIStorage]] -=== `++ERC721URIStorage++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721URIStorage.sol[{github-icon},role=heading-link] +=== `++ERC721URIStorage++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721URIStorage.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2340,15 +2416,19 @@ See {IERC721Metadata-tokenURI}. Sets `_tokenURI` as the tokenURI of `tokenId`. -Emits {MetadataUpdate}. +Emits {IERC4906-MetadataUpdate}. :_update: pass:normal[xref:#ERC721Votes-_update-address-uint256-address-[`++_update++`]] :_getVotingUnits: pass:normal[xref:#ERC721Votes-_getVotingUnits-address-[`++_getVotingUnits++`]] :_increaseBalance: pass:normal[xref:#ERC721Votes-_increaseBalance-address-uint128-[`++_increaseBalance++`]] +:_update-address-uint256-address: pass:normal[xref:#ERC721Votes-_update-address-uint256-address-[`++_update++`]] +:_getVotingUnits-address: pass:normal[xref:#ERC721Votes-_getVotingUnits-address-[`++_getVotingUnits++`]] +:_increaseBalance-address-uint128: pass:normal[xref:#ERC721Votes-_increaseBalance-address-uint128-[`++_increaseBalance++`]] + [.contract] [[ERC721Votes]] -=== `++ERC721Votes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Votes.sol[{github-icon},role=heading-link] +=== `++ERC721Votes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Votes.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2594,9 +2674,11 @@ See {ERC721-_increaseBalance}. We need that to account tokens that were minted i :supportsInterface: pass:normal[xref:#ERC721Royalty-supportsInterface-bytes4-[`++supportsInterface++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC721Royalty-supportsInterface-bytes4-[`++supportsInterface++`]] + [.contract] [[ERC721Royalty]] -=== `++ERC721Royalty++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Royalty.sol[{github-icon},role=heading-link] +=== `++ERC721Royalty++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Royalty.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2769,9 +2851,16 @@ See {IERC165-supportsInterface}. :_recover: pass:normal[xref:#ERC721Wrapper-_recover-address-uint256-[`++_recover++`]] :underlying: pass:normal[xref:#ERC721Wrapper-underlying--[`++underlying++`]] +:constructor-contract-IERC721: pass:normal[xref:#ERC721Wrapper-constructor-contract-IERC721-[`++constructor++`]] +:depositFor-address-uint256--: pass:normal[xref:#ERC721Wrapper-depositFor-address-uint256---[`++depositFor++`]] +:withdrawTo-address-uint256--: pass:normal[xref:#ERC721Wrapper-withdrawTo-address-uint256---[`++withdrawTo++`]] +:onERC721Received-address-address-uint256-bytes: pass:normal[xref:#ERC721Wrapper-onERC721Received-address-address-uint256-bytes-[`++onERC721Received++`]] +:_recover-address-uint256: pass:normal[xref:#ERC721Wrapper-_recover-address-uint256-[`++_recover++`]] +:underlying-: pass:normal[xref:#ERC721Wrapper-underlying--[`++underlying++`]] + [.contract] [[ERC721Wrapper]] -=== `++ERC721Wrapper++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/extensions/ERC721Wrapper.sol[{github-icon},role=heading-link] +=== `++ERC721Wrapper++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/extensions/ERC721Wrapper.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2966,9 +3055,11 @@ The received ERC-721 token couldn't be wrapped. :onERC721Received: pass:normal[xref:#ERC721Holder-onERC721Received-address-address-uint256-bytes-[`++onERC721Received++`]] +:onERC721Received-address-address-uint256-bytes: pass:normal[xref:#ERC721Holder-onERC721Received-address-address-uint256-bytes-[`++onERC721Received++`]] + [.contract] [[ERC721Holder]] -=== `++ERC721Holder++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/utils/ERC721Holder.sol[{github-icon},role=heading-link] +=== `++ERC721Holder++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/utils/ERC721Holder.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3001,9 +3092,11 @@ Always returns `IERC721Receiver.onERC721Received.selector`. :checkOnERC721Received: pass:normal[xref:#ERC721Utils-checkOnERC721Received-address-address-address-uint256-bytes-[`++checkOnERC721Received++`]] +:checkOnERC721Received-address-address-address-uint256-bytes: pass:normal[xref:#ERC721Utils-checkOnERC721Received-address-address-address-uint256-bytes-[`++checkOnERC721Received++`]] + [.contract] [[ERC721Utils]] -=== `++ERC721Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/ERC721/utils/ERC721Utils.sol[{github-icon},role=heading-link] +=== `++ERC721Utils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/ERC721/utils/ERC721Utils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3027,7 +3120,7 @@ _Available since v5.1._ [[ERC721Utils-checkOnERC721Received-address-address-address-uint256-bytes-]] ==== `[.contract-item-name]#++checkOnERC721Received++#++(address operator, address from, address to, uint256 tokenId, bytes data)++` [.item-kind]#internal# -Performs an acceptance check for the provided `operator` by calling {IERC721-onERC721Received} +Performs an acceptance check for the provided `operator` by calling {IERC721Receiver-onERC721Received} on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`). The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA). diff --git a/docs/modules/api/pages/token/common.adoc b/docs/modules/api/pages/token/common.adoc index d1622d1ae..f0fecc0b1 100644 --- a/docs/modules/api/pages/token/common.adoc +++ b/docs/modules/api/pages/token/common.adoc @@ -35,9 +35,17 @@ Functionality that is common to multiple token standards. :_setTokenRoyalty: pass:normal[xref:#ERC2981-_setTokenRoyalty-uint256-address-uint96-[`++_setTokenRoyalty++`]] :_resetTokenRoyalty: pass:normal[xref:#ERC2981-_resetTokenRoyalty-uint256-[`++_resetTokenRoyalty++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC2981-supportsInterface-bytes4-[`++supportsInterface++`]] +:royaltyInfo-uint256-uint256: pass:normal[xref:#ERC2981-royaltyInfo-uint256-uint256-[`++royaltyInfo++`]] +:_feeDenominator-: pass:normal[xref:#ERC2981-_feeDenominator--[`++_feeDenominator++`]] +:_setDefaultRoyalty-address-uint96: pass:normal[xref:#ERC2981-_setDefaultRoyalty-address-uint96-[`++_setDefaultRoyalty++`]] +:_deleteDefaultRoyalty-: pass:normal[xref:#ERC2981-_deleteDefaultRoyalty--[`++_deleteDefaultRoyalty++`]] +:_setTokenRoyalty-uint256-address-uint96: pass:normal[xref:#ERC2981-_setTokenRoyalty-uint256-address-uint96-[`++_setTokenRoyalty++`]] +:_resetTokenRoyalty-uint256: pass:normal[xref:#ERC2981-_resetTokenRoyalty-uint256-[`++_resetTokenRoyalty++`]] + [.contract] [[ERC2981]] -=== `++ERC2981++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/token/common/ERC2981.sol[{github-icon},role=heading-link] +=== `++ERC2981++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/token/common/ERC2981.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -171,7 +179,7 @@ The default royalty receiver is invalid. [[ERC2981-ERC2981InvalidTokenRoyalty-uint256-uint256-uint256-]] ==== `[.contract-item-name]#++ERC2981InvalidTokenRoyalty++#++(uint256 tokenId, uint256 numerator, uint256 denominator)++` [.item-kind]#error# -The royalty set for an specific `tokenId` is invalid (eg. (numerator / denominator) >= 1). +The royalty set for a specific `tokenId` is invalid (eg. (numerator / denominator) >= 1). [.contract-item] [[ERC2981-ERC2981InvalidTokenRoyaltyReceiver-uint256-address-]] diff --git a/docs/modules/api/pages/utils.adoc b/docs/modules/api/pages/utils.adoc index 9414289da..2f807add6 100644 --- a/docs/modules/api/pages/utils.adoc +++ b/docs/modules/api/pages/utils.adoc @@ -33,8 +33,9 @@ :Arrays: pass:normal[xref:utils.adoc#Arrays[`Arrays`]] :Base64: pass:normal[xref:utils.adoc#Base64[`Base64`]] :Bytes: pass:normal[xref:utils.adoc#Bytes[`Bytes`]] +:Calldata: pass:normal[xref:utils.adoc#Calldata[`Calldata`]] :Strings: pass:normal[xref:utils.adoc#Strings[`Strings`]] -:ShortString: pass:normal[xref:utils.adoc#ShortString[`ShortString`]] +:ShortStrings: pass:normal[xref:utils.adoc#ShortStrings[`ShortStrings`]] :SlotDerivation: pass:normal[xref:utils.adoc#SlotDerivation[`SlotDerivation`]] :StorageSlot: pass:normal[xref:utils.adoc#StorageSlot[`StorageSlot`]] :TransientSlot: pass:normal[xref:utils.adoc#TransientSlot[`TransientSlot`]] @@ -48,11 +49,16 @@ :CAIP10: pass:normal[xref:utils.adoc#CAIP10[`CAIP10`]] :EnumerableMap: pass:normal[xref:utils.adoc#EnumerableMap[`EnumerableMap`]] :EnumerableSet: pass:normal[xref:utils.adoc#EnumerableSet[`EnumerableSet`]] +:xref-Math-add512-uint256-uint256-: xref:utils.adoc#Math-add512-uint256-uint256- +:xref-Math-mul512-uint256-uint256-: xref:utils.adoc#Math-mul512-uint256-uint256- :xref-Math-tryAdd-uint256-uint256-: xref:utils.adoc#Math-tryAdd-uint256-uint256- :xref-Math-trySub-uint256-uint256-: xref:utils.adoc#Math-trySub-uint256-uint256- :xref-Math-tryMul-uint256-uint256-: xref:utils.adoc#Math-tryMul-uint256-uint256- :xref-Math-tryDiv-uint256-uint256-: xref:utils.adoc#Math-tryDiv-uint256-uint256- :xref-Math-tryMod-uint256-uint256-: xref:utils.adoc#Math-tryMod-uint256-uint256- +:xref-Math-saturatingAdd-uint256-uint256-: xref:utils.adoc#Math-saturatingAdd-uint256-uint256- +:xref-Math-saturatingSub-uint256-uint256-: xref:utils.adoc#Math-saturatingSub-uint256-uint256- +:xref-Math-saturatingMul-uint256-uint256-: xref:utils.adoc#Math-saturatingMul-uint256-uint256- :xref-Math-ternary-bool-uint256-uint256-: xref:utils.adoc#Math-ternary-bool-uint256-uint256- :xref-Math-max-uint256-uint256-: xref:utils.adoc#Math-max-uint256-uint256- :xref-Math-min-uint256-uint256-: xref:utils.adoc#Math-min-uint256-uint256- @@ -60,6 +66,8 @@ :xref-Math-ceilDiv-uint256-uint256-: xref:utils.adoc#Math-ceilDiv-uint256-uint256- :xref-Math-mulDiv-uint256-uint256-uint256-: xref:utils.adoc#Math-mulDiv-uint256-uint256-uint256- :xref-Math-mulDiv-uint256-uint256-uint256-enum-Math-Rounding-: xref:utils.adoc#Math-mulDiv-uint256-uint256-uint256-enum-Math-Rounding- +:xref-Math-mulShr-uint256-uint256-uint8-: xref:utils.adoc#Math-mulShr-uint256-uint256-uint8- +:xref-Math-mulShr-uint256-uint256-uint8-enum-Math-Rounding-: xref:utils.adoc#Math-mulShr-uint256-uint256-uint8-enum-Math-Rounding- :xref-Math-invMod-uint256-uint256-: xref:utils.adoc#Math-invMod-uint256-uint256- :xref-Math-invModPrime-uint256-uint256-: xref:utils.adoc#Math-invModPrime-uint256-uint256- :xref-Math-modExp-uint256-uint256-uint256-: xref:utils.adoc#Math-modExp-uint256-uint256-uint256- @@ -189,6 +197,7 @@ :xref-MessageHashUtils-toEthSignedMessageHash-bytes32-: xref:utils.adoc#MessageHashUtils-toEthSignedMessageHash-bytes32- :xref-MessageHashUtils-toEthSignedMessageHash-bytes-: xref:utils.adoc#MessageHashUtils-toEthSignedMessageHash-bytes- :xref-MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes-: xref:utils.adoc#MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes- +:xref-MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes32-: xref:utils.adoc#MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes32- :xref-MessageHashUtils-toTypedDataHash-bytes32-bytes32-: xref:utils.adoc#MessageHashUtils-toTypedDataHash-bytes32-bytes32- :ECDSA-recover: pass:normal[xref:utils.adoc#ECDSA-recover-bytes32-uint8-bytes32-bytes32-[`ECDSA.recover`]] :ECDSA-recover: pass:normal[xref:utils.adoc#ECDSA-recover-bytes32-uint8-bytes32-bytes32-[`ECDSA.recover`]] @@ -197,6 +206,7 @@ :xref-SignatureChecker-isValidSignatureNow-address-bytes32-bytes-: xref:utils.adoc#SignatureChecker-isValidSignatureNow-address-bytes32-bytes- :xref-SignatureChecker-isValidERC1271SignatureNow-address-bytes32-bytes-: xref:utils.adoc#SignatureChecker-isValidERC1271SignatureNow-address-bytes32-bytes- :xref-Hashes-commutativeKeccak256-bytes32-bytes32-: xref:utils.adoc#Hashes-commutativeKeccak256-bytes32-bytes32- +:xref-Hashes-efficientKeccak256-bytes32-bytes32-: xref:utils.adoc#Hashes-efficientKeccak256-bytes32-bytes32- :xref-MerkleProof-verify-bytes32---bytes32-bytes32-: xref:utils.adoc#MerkleProof-verify-bytes32---bytes32-bytes32- :xref-MerkleProof-processProof-bytes32---bytes32-: xref:utils.adoc#MerkleProof-processProof-bytes32---bytes32- :xref-MerkleProof-verify-bytes32---bytes32-bytes32-function--bytes32-bytes32--view-returns--bytes32--: xref:utils.adoc#MerkleProof-verify-bytes32---bytes32-bytes32-function--bytes32-bytes32--view-returns--bytes32-- @@ -225,7 +235,6 @@ :xref-ReentrancyGuardTransient-ReentrancyGuardReentrantCall--: xref:utils.adoc#ReentrancyGuardTransient-ReentrancyGuardReentrantCall-- :xref-Pausable-whenNotPaused--: xref:utils.adoc#Pausable-whenNotPaused-- :xref-Pausable-whenPaused--: xref:utils.adoc#Pausable-whenPaused-- -:xref-Pausable-constructor--: xref:utils.adoc#Pausable-constructor-- :xref-Pausable-paused--: xref:utils.adoc#Pausable-paused-- :xref-Pausable-_requireNotPaused--: xref:utils.adoc#Pausable-_requireNotPaused-- :xref-Pausable-_requirePaused--: xref:utils.adoc#Pausable-_requirePaused-- @@ -275,6 +284,7 @@ :xref-BitMaps-unset-struct-BitMaps-BitMap-uint256-: xref:utils.adoc#BitMaps-unset-struct-BitMaps-BitMap-uint256- :xref-EnumerableMap-set-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-bytes32-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-bytes32- :xref-EnumerableMap-remove-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32- +:xref-EnumerableMap-clear-struct-EnumerableMap-Bytes32ToBytes32Map-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToBytes32Map- :xref-EnumerableMap-contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32- :xref-EnumerableMap-length-struct-EnumerableMap-Bytes32ToBytes32Map-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-Bytes32ToBytes32Map- :xref-EnumerableMap-at-struct-EnumerableMap-Bytes32ToBytes32Map-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-Bytes32ToBytes32Map-uint256- @@ -283,6 +293,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-Bytes32ToBytes32Map-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-Bytes32ToBytes32Map- :xref-EnumerableMap-set-struct-EnumerableMap-UintToUintMap-uint256-uint256-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-UintToUintMap-uint256-uint256- :xref-EnumerableMap-remove-struct-EnumerableMap-UintToUintMap-uint256-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-UintToUintMap-uint256- +:xref-EnumerableMap-clear-struct-EnumerableMap-UintToUintMap-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-UintToUintMap- :xref-EnumerableMap-contains-struct-EnumerableMap-UintToUintMap-uint256-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-UintToUintMap-uint256- :xref-EnumerableMap-length-struct-EnumerableMap-UintToUintMap-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-UintToUintMap- :xref-EnumerableMap-at-struct-EnumerableMap-UintToUintMap-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-UintToUintMap-uint256- @@ -291,6 +302,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-UintToUintMap-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-UintToUintMap- :xref-EnumerableMap-set-struct-EnumerableMap-UintToAddressMap-uint256-address-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-UintToAddressMap-uint256-address- :xref-EnumerableMap-remove-struct-EnumerableMap-UintToAddressMap-uint256-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-UintToAddressMap-uint256- +:xref-EnumerableMap-clear-struct-EnumerableMap-UintToAddressMap-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-UintToAddressMap- :xref-EnumerableMap-contains-struct-EnumerableMap-UintToAddressMap-uint256-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-UintToAddressMap-uint256- :xref-EnumerableMap-length-struct-EnumerableMap-UintToAddressMap-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-UintToAddressMap- :xref-EnumerableMap-at-struct-EnumerableMap-UintToAddressMap-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-UintToAddressMap-uint256- @@ -299,6 +311,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-UintToAddressMap-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-UintToAddressMap- :xref-EnumerableMap-set-struct-EnumerableMap-UintToBytes32Map-uint256-bytes32-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-UintToBytes32Map-uint256-bytes32- :xref-EnumerableMap-remove-struct-EnumerableMap-UintToBytes32Map-uint256-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-UintToBytes32Map-uint256- +:xref-EnumerableMap-clear-struct-EnumerableMap-UintToBytes32Map-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-UintToBytes32Map- :xref-EnumerableMap-contains-struct-EnumerableMap-UintToBytes32Map-uint256-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-UintToBytes32Map-uint256- :xref-EnumerableMap-length-struct-EnumerableMap-UintToBytes32Map-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-UintToBytes32Map- :xref-EnumerableMap-at-struct-EnumerableMap-UintToBytes32Map-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-UintToBytes32Map-uint256- @@ -307,6 +320,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-UintToBytes32Map-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-UintToBytes32Map- :xref-EnumerableMap-set-struct-EnumerableMap-AddressToUintMap-address-uint256-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-AddressToUintMap-address-uint256- :xref-EnumerableMap-remove-struct-EnumerableMap-AddressToUintMap-address-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-AddressToUintMap-address- +:xref-EnumerableMap-clear-struct-EnumerableMap-AddressToUintMap-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-AddressToUintMap- :xref-EnumerableMap-contains-struct-EnumerableMap-AddressToUintMap-address-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-AddressToUintMap-address- :xref-EnumerableMap-length-struct-EnumerableMap-AddressToUintMap-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-AddressToUintMap- :xref-EnumerableMap-at-struct-EnumerableMap-AddressToUintMap-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-AddressToUintMap-uint256- @@ -315,6 +329,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-AddressToUintMap-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-AddressToUintMap- :xref-EnumerableMap-set-struct-EnumerableMap-AddressToAddressMap-address-address-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-AddressToAddressMap-address-address- :xref-EnumerableMap-remove-struct-EnumerableMap-AddressToAddressMap-address-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-AddressToAddressMap-address- +:xref-EnumerableMap-clear-struct-EnumerableMap-AddressToAddressMap-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-AddressToAddressMap- :xref-EnumerableMap-contains-struct-EnumerableMap-AddressToAddressMap-address-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-AddressToAddressMap-address- :xref-EnumerableMap-length-struct-EnumerableMap-AddressToAddressMap-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-AddressToAddressMap- :xref-EnumerableMap-at-struct-EnumerableMap-AddressToAddressMap-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-AddressToAddressMap-uint256- @@ -323,6 +338,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-AddressToAddressMap-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-AddressToAddressMap- :xref-EnumerableMap-set-struct-EnumerableMap-AddressToBytes32Map-address-bytes32-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-AddressToBytes32Map-address-bytes32- :xref-EnumerableMap-remove-struct-EnumerableMap-AddressToBytes32Map-address-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-AddressToBytes32Map-address- +:xref-EnumerableMap-clear-struct-EnumerableMap-AddressToBytes32Map-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-AddressToBytes32Map- :xref-EnumerableMap-contains-struct-EnumerableMap-AddressToBytes32Map-address-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-AddressToBytes32Map-address- :xref-EnumerableMap-length-struct-EnumerableMap-AddressToBytes32Map-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-AddressToBytes32Map- :xref-EnumerableMap-at-struct-EnumerableMap-AddressToBytes32Map-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-AddressToBytes32Map-uint256- @@ -331,6 +347,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-AddressToBytes32Map-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-AddressToBytes32Map- :xref-EnumerableMap-set-struct-EnumerableMap-Bytes32ToUintMap-bytes32-uint256-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-Bytes32ToUintMap-bytes32-uint256- :xref-EnumerableMap-remove-struct-EnumerableMap-Bytes32ToUintMap-bytes32-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToUintMap-bytes32- +:xref-EnumerableMap-clear-struct-EnumerableMap-Bytes32ToUintMap-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToUintMap- :xref-EnumerableMap-contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32- :xref-EnumerableMap-length-struct-EnumerableMap-Bytes32ToUintMap-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-Bytes32ToUintMap- :xref-EnumerableMap-at-struct-EnumerableMap-Bytes32ToUintMap-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-Bytes32ToUintMap-uint256- @@ -339,6 +356,7 @@ :xref-EnumerableMap-keys-struct-EnumerableMap-Bytes32ToUintMap-: xref:utils.adoc#EnumerableMap-keys-struct-EnumerableMap-Bytes32ToUintMap- :xref-EnumerableMap-set-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-address-: xref:utils.adoc#EnumerableMap-set-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-address- :xref-EnumerableMap-remove-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-: xref:utils.adoc#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToAddressMap-bytes32- +:xref-EnumerableMap-clear-struct-EnumerableMap-Bytes32ToAddressMap-: xref:utils.adoc#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToAddressMap- :xref-EnumerableMap-contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-: xref:utils.adoc#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32- :xref-EnumerableMap-length-struct-EnumerableMap-Bytes32ToAddressMap-: xref:utils.adoc#EnumerableMap-length-struct-EnumerableMap-Bytes32ToAddressMap- :xref-EnumerableMap-at-struct-EnumerableMap-Bytes32ToAddressMap-uint256-: xref:utils.adoc#EnumerableMap-at-struct-EnumerableMap-Bytes32ToAddressMap-uint256- @@ -348,18 +366,21 @@ :xref-EnumerableMap-EnumerableMapNonexistentKey-bytes32-: xref:utils.adoc#EnumerableMap-EnumerableMapNonexistentKey-bytes32- :xref-EnumerableSet-add-struct-EnumerableSet-Bytes32Set-bytes32-: xref:utils.adoc#EnumerableSet-add-struct-EnumerableSet-Bytes32Set-bytes32- :xref-EnumerableSet-remove-struct-EnumerableSet-Bytes32Set-bytes32-: xref:utils.adoc#EnumerableSet-remove-struct-EnumerableSet-Bytes32Set-bytes32- +:xref-EnumerableSet-clear-struct-EnumerableSet-Bytes32Set-: xref:utils.adoc#EnumerableSet-clear-struct-EnumerableSet-Bytes32Set- :xref-EnumerableSet-contains-struct-EnumerableSet-Bytes32Set-bytes32-: xref:utils.adoc#EnumerableSet-contains-struct-EnumerableSet-Bytes32Set-bytes32- :xref-EnumerableSet-length-struct-EnumerableSet-Bytes32Set-: xref:utils.adoc#EnumerableSet-length-struct-EnumerableSet-Bytes32Set- :xref-EnumerableSet-at-struct-EnumerableSet-Bytes32Set-uint256-: xref:utils.adoc#EnumerableSet-at-struct-EnumerableSet-Bytes32Set-uint256- :xref-EnumerableSet-values-struct-EnumerableSet-Bytes32Set-: xref:utils.adoc#EnumerableSet-values-struct-EnumerableSet-Bytes32Set- :xref-EnumerableSet-add-struct-EnumerableSet-AddressSet-address-: xref:utils.adoc#EnumerableSet-add-struct-EnumerableSet-AddressSet-address- :xref-EnumerableSet-remove-struct-EnumerableSet-AddressSet-address-: xref:utils.adoc#EnumerableSet-remove-struct-EnumerableSet-AddressSet-address- +:xref-EnumerableSet-clear-struct-EnumerableSet-AddressSet-: xref:utils.adoc#EnumerableSet-clear-struct-EnumerableSet-AddressSet- :xref-EnumerableSet-contains-struct-EnumerableSet-AddressSet-address-: xref:utils.adoc#EnumerableSet-contains-struct-EnumerableSet-AddressSet-address- :xref-EnumerableSet-length-struct-EnumerableSet-AddressSet-: xref:utils.adoc#EnumerableSet-length-struct-EnumerableSet-AddressSet- :xref-EnumerableSet-at-struct-EnumerableSet-AddressSet-uint256-: xref:utils.adoc#EnumerableSet-at-struct-EnumerableSet-AddressSet-uint256- :xref-EnumerableSet-values-struct-EnumerableSet-AddressSet-: xref:utils.adoc#EnumerableSet-values-struct-EnumerableSet-AddressSet- :xref-EnumerableSet-add-struct-EnumerableSet-UintSet-uint256-: xref:utils.adoc#EnumerableSet-add-struct-EnumerableSet-UintSet-uint256- :xref-EnumerableSet-remove-struct-EnumerableSet-UintSet-uint256-: xref:utils.adoc#EnumerableSet-remove-struct-EnumerableSet-UintSet-uint256- +:xref-EnumerableSet-clear-struct-EnumerableSet-UintSet-: xref:utils.adoc#EnumerableSet-clear-struct-EnumerableSet-UintSet- :xref-EnumerableSet-contains-struct-EnumerableSet-UintSet-uint256-: xref:utils.adoc#EnumerableSet-contains-struct-EnumerableSet-UintSet-uint256- :xref-EnumerableSet-length-struct-EnumerableSet-UintSet-: xref:utils.adoc#EnumerableSet-length-struct-EnumerableSet-UintSet- :xref-EnumerableSet-at-struct-EnumerableSet-UintSet-uint256-: xref:utils.adoc#EnumerableSet-at-struct-EnumerableSet-UintSet-uint256- @@ -432,12 +453,18 @@ :xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-function--bytes32-bytes32--view-returns--bytes32--: xref:utils.adoc#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-function--bytes32-bytes32--view-returns--bytes32-- :xref-MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-: xref:utils.adoc#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32- :xref-MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-function--bytes32-bytes32--view-returns--bytes32--: xref:utils.adoc#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-function--bytes32-bytes32--view-returns--bytes32-- +:xref-MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---: xref:utils.adoc#MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32--- +:xref-MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--: xref:utils.adoc#MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32-- :xref-MerkleTree-depth-struct-MerkleTree-Bytes32PushTree-: xref:utils.adoc#MerkleTree-depth-struct-MerkleTree-Bytes32PushTree- +:xref-MerkleTree-MerkleTreeUpdateInvalidIndex-uint256-uint256-: xref:utils.adoc#MerkleTree-MerkleTreeUpdateInvalidIndex-uint256-uint256- +:xref-MerkleTree-MerkleTreeUpdateInvalidProof--: xref:utils.adoc#MerkleTree-MerkleTreeUpdateInvalidProof-- :Hashes-commutativeKeccak256: pass:normal[xref:utils.adoc#Hashes-commutativeKeccak256-bytes32-bytes32-[`Hashes.commutativeKeccak256`]] :xref-MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-: xref:utils.adoc#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32- :xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-: xref:utils.adoc#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32- :Hashes-commutativeKeccak256: pass:normal[xref:utils.adoc#Hashes-commutativeKeccak256-bytes32-bytes32-[`Hashes.commutativeKeccak256`]] :xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-: xref:utils.adoc#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32- +:Hashes-commutativeKeccak256: pass:normal[xref:utils.adoc#Hashes-commutativeKeccak256-bytes32-bytes32-[`Hashes.commutativeKeccak256`]] +:xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-: xref:utils.adoc#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32- :xref-Create2-deploy-uint256-bytes32-bytes-: xref:utils.adoc#Create2-deploy-uint256-bytes32-bytes- :xref-Create2-computeAddress-bytes32-bytes32-: xref:utils.adoc#Create2-computeAddress-bytes32-bytes32- :xref-Create2-computeAddress-bytes32-bytes32-address-: xref:utils.adoc#Create2-computeAddress-bytes32-bytes32-address- @@ -478,6 +505,14 @@ :xref-Base64-encodeURL-bytes-: xref:utils.adoc#Base64-encodeURL-bytes- :xref-Base64-_TABLE-string: xref:utils.adoc#Base64-_TABLE-string :xref-Base64-_TABLE_URL-string: xref:utils.adoc#Base64-_TABLE_URL-string +:xref-Bytes-indexOf-bytes-bytes1-: xref:utils.adoc#Bytes-indexOf-bytes-bytes1- +:xref-Bytes-indexOf-bytes-bytes1-uint256-: xref:utils.adoc#Bytes-indexOf-bytes-bytes1-uint256- +:xref-Bytes-lastIndexOf-bytes-bytes1-: xref:utils.adoc#Bytes-lastIndexOf-bytes-bytes1- +:xref-Bytes-lastIndexOf-bytes-bytes1-uint256-: xref:utils.adoc#Bytes-lastIndexOf-bytes-bytes1-uint256- +:xref-Bytes-slice-bytes-uint256-: xref:utils.adoc#Bytes-slice-bytes-uint256- +:xref-Bytes-slice-bytes-uint256-uint256-: xref:utils.adoc#Bytes-slice-bytes-uint256-uint256- +:xref-Calldata-emptyBytes--: xref:utils.adoc#Calldata-emptyBytes-- +:xref-Calldata-emptyString--: xref:utils.adoc#Calldata-emptyString-- :xref-Strings-toString-uint256-: xref:utils.adoc#Strings-toString-uint256- :xref-Strings-toStringSigned-int256-: xref:utils.adoc#Strings-toStringSigned-int256- :xref-Strings-toHexString-uint256-: xref:utils.adoc#Strings-toHexString-uint256- @@ -501,6 +536,7 @@ :xref-Strings-parseAddress-string-uint256-uint256-: xref:utils.adoc#Strings-parseAddress-string-uint256-uint256- :xref-Strings-tryParseAddress-string-: xref:utils.adoc#Strings-tryParseAddress-string- :xref-Strings-tryParseAddress-string-uint256-uint256-: xref:utils.adoc#Strings-tryParseAddress-string-uint256-uint256- +:xref-Strings-escapeJSON-string-: xref:utils.adoc#Strings-escapeJSON-string- :xref-Strings-StringsInsufficientHexLength-uint256-uint256-: xref:utils.adoc#Strings-StringsInsufficientHexLength-uint256-uint256- :xref-Strings-StringsInvalidChar--: xref:utils.adoc#Strings-StringsInvalidChar-- :xref-Strings-StringsInvalidAddressFormat--: xref:utils.adoc#Strings-StringsInvalidAddressFormat-- @@ -549,7 +585,9 @@ :xref-TransientSlot-tstore-TransientSlot-Uint256Slot-uint256-: xref:utils.adoc#TransientSlot-tstore-TransientSlot-Uint256Slot-uint256- :xref-TransientSlot-tload-TransientSlot-Int256Slot-: xref:utils.adoc#TransientSlot-tload-TransientSlot-Int256Slot- :xref-TransientSlot-tstore-TransientSlot-Int256Slot-int256-: xref:utils.adoc#TransientSlot-tstore-TransientSlot-Int256Slot-int256- +:Context-_msgSender: pass:normal[xref:utils.adoc#Context-_msgSender--[`Context._msgSender`]] :ERC2771Context: pass:normal[xref:metatx.adoc#ERC2771Context[`ERC2771Context`]] +:Context-_msgSender: pass:normal[xref:utils.adoc#Context-_msgSender--[`Context._msgSender`]] :xref-Multicall-multicall-bytes---: xref:utils.adoc#Multicall-multicall-bytes--- :xref-Context-_msgSender--: xref:utils.adoc#Context-_msgSender-- :xref-Context-_msgData--: xref:utils.adoc#Context-_msgData-- @@ -780,6 +818,15 @@ :xref-Panic-INVALID_INTERNAL_FUNCTION-uint256: xref:utils.adoc#Panic-INVALID_INTERNAL_FUNCTION-uint256 :xref-Comparators-lt-uint256-uint256-: xref:utils.adoc#Comparators-lt-uint256-uint256- :xref-Comparators-gt-uint256-uint256-: xref:utils.adoc#Comparators-gt-uint256-uint256- +:xref-CAIP2-local--: xref:utils.adoc#CAIP2-local-- +:xref-CAIP2-format-string-string-: xref:utils.adoc#CAIP2-format-string-string- +:xref-CAIP2-parse-string-: xref:utils.adoc#CAIP2-parse-string- +:CAIP2: pass:normal[xref:utils.adoc#CAIP2[`CAIP2`]] +:Strings-toChecksumHexString: pass:normal[xref:utils.adoc#Strings-toChecksumHexString-address-[`Strings.toChecksumHexString`]] +:xref-CAIP10-local-address-: xref:utils.adoc#CAIP10-local-address- +:xref-CAIP10-format-string-string-: xref:utils.adoc#CAIP10-format-string-string- +:xref-CAIP10-parse-string-: xref:utils.adoc#CAIP10-parse-string- +:CAIP2: pass:normal[xref:utils.adoc#CAIP2[`CAIP2`]] = Utilities [.readme-notice] @@ -800,12 +847,12 @@ Miscellaneous contracts and libraries containing utility functions you can use t * {ReentrancyGuardTransient}: Variant of {ReentrancyGuard} that uses transient storage (https://eips.ethereum.org/EIPS/eip-1153[EIP-1153]). * {Pausable}: A common emergency response mechanism that can pause functionality while a remediation is pending. * {Nonces}: Utility for tracking and verifying address nonces that only increment. - * {NoncesKeyed}: Alternative to {Nonces}, that support key-ed nonces following https://eips.ethereum.org/EIPS/eip-4337#semi-abstracted-nonce-support[ERC-4337 speciciations]. + * {NoncesKeyed}: Alternative to {Nonces}, that support keyed nonces following https://eips.ethereum.org/EIPS/eip-4337#semi-abstracted-nonce-support[ERC-4337 specifications]. * {ERC165}, {ERC165Checker}: Utilities for inspecting interfaces supported by contracts. * {BitMaps}: A simple library to manage boolean value mapped to a numerical index in an efficient way. * {EnumerableMap}: A type like Solidity's https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`], but with key-value _enumeration_: this will let you know how many entries a mapping has, and iterate over them (which is not possible with `mapping`). * {EnumerableSet}: Like {EnumerableMap}, but for https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets]. Can be used to store privileged accounts, issued IDs, etc. - * {DoubleEndedQueue}: An implementation of a https://en.wikipedia.org/wiki/Double-ended_queue[double ended queue] whose values can be removed added or remove from both sides. Useful for FIFO and LIFO structures. + * {DoubleEndedQueue}: An implementation of a https://en.wikipedia.org/wiki/Double-ended_queue[double ended queue] whose values can be added or removed from both sides. Useful for FIFO and LIFO structures. * {CircularBuffer}: A data structure to store the last N values pushed to it. * {Checkpoints}: A data structure to store values mapped to a strictly increasing key. Can be used for storing and accessing values over time. * {Heap}: A library that implements a https://en.wikipedia.org/wiki/Binary_heap[binary heap] in storage. @@ -815,8 +862,9 @@ Miscellaneous contracts and libraries containing utility functions you can use t * {Arrays}: Collection of functions that operate on https://docs.soliditylang.org/en/latest/types.html#arrays[`arrays`]. * {Base64}: On-chain base64 and base64URL encoding according to https://datatracker.ietf.org/doc/html/rfc4648[RFC-4648]. * {Bytes}: Common operations on bytes objects. + * {Calldata}: Helpers for manipulating calldata. * {Strings}: Common operations for strings formatting. - * {ShortString}: Library to encode (and decode) short strings into (or from) a single bytes32 slot for optimizing costs. Short strings are limited to 31 characters. + * {ShortStrings}: Library to encode (and decode) short strings into (or from) a single bytes32 slot for optimizing costs. Short strings are limited to 31 characters. * {SlotDerivation}: Methods for deriving storage slot from ERC-7201 namespaces as well as from constructions such as mapping and arrays. * {StorageSlot}: Methods for accessing specific storage slots formatted as common primitive types. * {TransientSlot}: Primitives for reading from and writing to transient storage (only value types are currently supported). @@ -824,7 +872,7 @@ Miscellaneous contracts and libraries containing utility functions you can use t * {Context}: A utility for abstracting the sender and calldata in the current execution context. * {Packing}: A library for packing and unpacking multiple values into bytes32 * {Panic}: A library to revert with https://docs.soliditylang.org/en/v0.8.20/control-structures.html#panic-via-assert-and-error-via-require[Solidity panic codes]. - * {Comparators}: A library that contains comparator functions to use with with the {Heap} library. + * {Comparators}: A library that contains comparator functions to use with the {Heap} library. * {CAIP2}, {CAIP10}: Libraries for formatting and parsing CAIP-2 and CAIP-10 identifiers. [NOTE] @@ -835,11 +883,16 @@ Because Solidity does not support generic types, {EnumerableMap} and {Enumerable == Math :Rounding: pass:normal[xref:#Math-Rounding[`++Rounding++`]] +:add512: pass:normal[xref:#Math-add512-uint256-uint256-[`++add512++`]] +:mul512: pass:normal[xref:#Math-mul512-uint256-uint256-[`++mul512++`]] :tryAdd: pass:normal[xref:#Math-tryAdd-uint256-uint256-[`++tryAdd++`]] :trySub: pass:normal[xref:#Math-trySub-uint256-uint256-[`++trySub++`]] :tryMul: pass:normal[xref:#Math-tryMul-uint256-uint256-[`++tryMul++`]] :tryDiv: pass:normal[xref:#Math-tryDiv-uint256-uint256-[`++tryDiv++`]] :tryMod: pass:normal[xref:#Math-tryMod-uint256-uint256-[`++tryMod++`]] +:saturatingAdd: pass:normal[xref:#Math-saturatingAdd-uint256-uint256-[`++saturatingAdd++`]] +:saturatingSub: pass:normal[xref:#Math-saturatingSub-uint256-uint256-[`++saturatingSub++`]] +:saturatingMul: pass:normal[xref:#Math-saturatingMul-uint256-uint256-[`++saturatingMul++`]] :ternary: pass:normal[xref:#Math-ternary-bool-uint256-uint256-[`++ternary++`]] :max: pass:normal[xref:#Math-max-uint256-uint256-[`++max++`]] :min: pass:normal[xref:#Math-min-uint256-uint256-[`++min++`]] @@ -847,6 +900,8 @@ Because Solidity does not support generic types, {EnumerableMap} and {Enumerable :ceilDiv: pass:normal[xref:#Math-ceilDiv-uint256-uint256-[`++ceilDiv++`]] :mulDiv: pass:normal[xref:#Math-mulDiv-uint256-uint256-uint256-[`++mulDiv++`]] :mulDiv: pass:normal[xref:#Math-mulDiv-uint256-uint256-uint256-enum-Math-Rounding-[`++mulDiv++`]] +:mulShr: pass:normal[xref:#Math-mulShr-uint256-uint256-uint8-[`++mulShr++`]] +:mulShr: pass:normal[xref:#Math-mulShr-uint256-uint256-uint8-enum-Math-Rounding-[`++mulShr++`]] :invMod: pass:normal[xref:#Math-invMod-uint256-uint256-[`++invMod++`]] :invModPrime: pass:normal[xref:#Math-invModPrime-uint256-uint256-[`++invModPrime++`]] :modExp: pass:normal[xref:#Math-modExp-uint256-uint256-uint256-[`++modExp++`]] @@ -863,9 +918,44 @@ Because Solidity does not support generic types, {EnumerableMap} and {Enumerable :log256: pass:normal[xref:#Math-log256-uint256-enum-Math-Rounding-[`++log256++`]] :unsignedRoundsUp: pass:normal[xref:#Math-unsignedRoundsUp-enum-Math-Rounding-[`++unsignedRoundsUp++`]] +:add512-uint256-uint256: pass:normal[xref:#Math-add512-uint256-uint256-[`++add512++`]] +:mul512-uint256-uint256: pass:normal[xref:#Math-mul512-uint256-uint256-[`++mul512++`]] +:tryAdd-uint256-uint256: pass:normal[xref:#Math-tryAdd-uint256-uint256-[`++tryAdd++`]] +:trySub-uint256-uint256: pass:normal[xref:#Math-trySub-uint256-uint256-[`++trySub++`]] +:tryMul-uint256-uint256: pass:normal[xref:#Math-tryMul-uint256-uint256-[`++tryMul++`]] +:tryDiv-uint256-uint256: pass:normal[xref:#Math-tryDiv-uint256-uint256-[`++tryDiv++`]] +:tryMod-uint256-uint256: pass:normal[xref:#Math-tryMod-uint256-uint256-[`++tryMod++`]] +:saturatingAdd-uint256-uint256: pass:normal[xref:#Math-saturatingAdd-uint256-uint256-[`++saturatingAdd++`]] +:saturatingSub-uint256-uint256: pass:normal[xref:#Math-saturatingSub-uint256-uint256-[`++saturatingSub++`]] +:saturatingMul-uint256-uint256: pass:normal[xref:#Math-saturatingMul-uint256-uint256-[`++saturatingMul++`]] +:ternary-bool-uint256-uint256: pass:normal[xref:#Math-ternary-bool-uint256-uint256-[`++ternary++`]] +:max-uint256-uint256: pass:normal[xref:#Math-max-uint256-uint256-[`++max++`]] +:min-uint256-uint256: pass:normal[xref:#Math-min-uint256-uint256-[`++min++`]] +:average-uint256-uint256: pass:normal[xref:#Math-average-uint256-uint256-[`++average++`]] +:ceilDiv-uint256-uint256: pass:normal[xref:#Math-ceilDiv-uint256-uint256-[`++ceilDiv++`]] +:mulDiv-uint256-uint256-uint256: pass:normal[xref:#Math-mulDiv-uint256-uint256-uint256-[`++mulDiv++`]] +:mulDiv-uint256-uint256-uint256-enum-Math-Rounding: pass:normal[xref:#Math-mulDiv-uint256-uint256-uint256-enum-Math-Rounding-[`++mulDiv++`]] +:mulShr-uint256-uint256-uint8: pass:normal[xref:#Math-mulShr-uint256-uint256-uint8-[`++mulShr++`]] +:mulShr-uint256-uint256-uint8-enum-Math-Rounding: pass:normal[xref:#Math-mulShr-uint256-uint256-uint8-enum-Math-Rounding-[`++mulShr++`]] +:invMod-uint256-uint256: pass:normal[xref:#Math-invMod-uint256-uint256-[`++invMod++`]] +:invModPrime-uint256-uint256: pass:normal[xref:#Math-invModPrime-uint256-uint256-[`++invModPrime++`]] +:modExp-uint256-uint256-uint256: pass:normal[xref:#Math-modExp-uint256-uint256-uint256-[`++modExp++`]] +:tryModExp-uint256-uint256-uint256: pass:normal[xref:#Math-tryModExp-uint256-uint256-uint256-[`++tryModExp++`]] +:modExp-bytes-bytes-bytes: pass:normal[xref:#Math-modExp-bytes-bytes-bytes-[`++modExp++`]] +:tryModExp-bytes-bytes-bytes: pass:normal[xref:#Math-tryModExp-bytes-bytes-bytes-[`++tryModExp++`]] +:sqrt-uint256: pass:normal[xref:#Math-sqrt-uint256-[`++sqrt++`]] +:sqrt-uint256-enum-Math-Rounding: pass:normal[xref:#Math-sqrt-uint256-enum-Math-Rounding-[`++sqrt++`]] +:log2-uint256: pass:normal[xref:#Math-log2-uint256-[`++log2++`]] +:log2-uint256-enum-Math-Rounding: pass:normal[xref:#Math-log2-uint256-enum-Math-Rounding-[`++log2++`]] +:log10-uint256: pass:normal[xref:#Math-log10-uint256-[`++log10++`]] +:log10-uint256-enum-Math-Rounding: pass:normal[xref:#Math-log10-uint256-enum-Math-Rounding-[`++log10++`]] +:log256-uint256: pass:normal[xref:#Math-log256-uint256-[`++log256++`]] +:log256-uint256-enum-Math-Rounding: pass:normal[xref:#Math-log256-uint256-enum-Math-Rounding-[`++log256++`]] +:unsignedRoundsUp-enum-Math-Rounding: pass:normal[xref:#Math-unsignedRoundsUp-enum-Math-Rounding-[`++unsignedRoundsUp++`]] + [.contract] [[Math]] -=== `++Math++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/math/Math.sol[{github-icon},role=heading-link] +=== `++Math++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/math/Math.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -877,11 +967,16 @@ Standard math utilities missing in the Solidity language. [.contract-index] .Functions -- +* {xref-Math-add512-uint256-uint256-}[`++add512(a, b)++`] +* {xref-Math-mul512-uint256-uint256-}[`++mul512(a, b)++`] * {xref-Math-tryAdd-uint256-uint256-}[`++tryAdd(a, b)++`] * {xref-Math-trySub-uint256-uint256-}[`++trySub(a, b)++`] * {xref-Math-tryMul-uint256-uint256-}[`++tryMul(a, b)++`] * {xref-Math-tryDiv-uint256-uint256-}[`++tryDiv(a, b)++`] * {xref-Math-tryMod-uint256-uint256-}[`++tryMod(a, b)++`] +* {xref-Math-saturatingAdd-uint256-uint256-}[`++saturatingAdd(a, b)++`] +* {xref-Math-saturatingSub-uint256-uint256-}[`++saturatingSub(a, b)++`] +* {xref-Math-saturatingMul-uint256-uint256-}[`++saturatingMul(a, b)++`] * {xref-Math-ternary-bool-uint256-uint256-}[`++ternary(condition, a, b)++`] * {xref-Math-max-uint256-uint256-}[`++max(a, b)++`] * {xref-Math-min-uint256-uint256-}[`++min(a, b)++`] @@ -889,6 +984,8 @@ Standard math utilities missing in the Solidity language. * {xref-Math-ceilDiv-uint256-uint256-}[`++ceilDiv(a, b)++`] * {xref-Math-mulDiv-uint256-uint256-uint256-}[`++mulDiv(x, y, denominator)++`] * {xref-Math-mulDiv-uint256-uint256-uint256-enum-Math-Rounding-}[`++mulDiv(x, y, denominator, rounding)++`] +* {xref-Math-mulShr-uint256-uint256-uint8-}[`++mulShr(x, y, n)++`] +* {xref-Math-mulShr-uint256-uint256-uint8-enum-Math-Rounding-}[`++mulShr(x, y, n, rounding)++`] * {xref-Math-invMod-uint256-uint256-}[`++invMod(a, n)++`] * {xref-Math-invModPrime-uint256-uint256-}[`++invModPrime(a, p)++`] * {xref-Math-modExp-uint256-uint256-uint256-}[`++modExp(b, e, m)++`] @@ -897,33 +994,49 @@ Standard math utilities missing in the Solidity language. * {xref-Math-tryModExp-bytes-bytes-bytes-}[`++tryModExp(b, e, m)++`] * {xref-Math-sqrt-uint256-}[`++sqrt(a)++`] * {xref-Math-sqrt-uint256-enum-Math-Rounding-}[`++sqrt(a, rounding)++`] -* {xref-Math-log2-uint256-}[`++log2(value)++`] +* {xref-Math-log2-uint256-}[`++log2(x)++`] * {xref-Math-log2-uint256-enum-Math-Rounding-}[`++log2(value, rounding)++`] * {xref-Math-log10-uint256-}[`++log10(value)++`] * {xref-Math-log10-uint256-enum-Math-Rounding-}[`++log10(value, rounding)++`] -* {xref-Math-log256-uint256-}[`++log256(value)++`] +* {xref-Math-log256-uint256-}[`++log256(x)++`] * {xref-Math-log256-uint256-enum-Math-Rounding-}[`++log256(value, rounding)++`] * {xref-Math-unsignedRoundsUp-enum-Math-Rounding-}[`++unsignedRoundsUp(rounding)++`] -- +[.contract-item] +[[Math-add512-uint256-uint256-]] +==== `[.contract-item-name]#++add512++#++(uint256 a, uint256 b) → uint256 high, uint256 low++` [.item-kind]#internal# + +Return the 512-bit addition of two uint256. + +The result is stored in two 256 variables such that sum = high * 2²⁵⁶ + low. + +[.contract-item] +[[Math-mul512-uint256-uint256-]] +==== `[.contract-item-name]#++mul512++#++(uint256 a, uint256 b) → uint256 high, uint256 low++` [.item-kind]#internal# + +Return the 512-bit multiplication of two uint256. + +The result is stored in two 256 variables such that product = high * 2²⁵⁶ + low. + [.contract-item] [[Math-tryAdd-uint256-uint256-]] ==== `[.contract-item-name]#++tryAdd++#++(uint256 a, uint256 b) → bool success, uint256 result++` [.item-kind]#internal# -Returns the addition of two unsigned integers, with an success flag (no overflow). +Returns the addition of two unsigned integers, with a success flag (no overflow). [.contract-item] [[Math-trySub-uint256-uint256-]] ==== `[.contract-item-name]#++trySub++#++(uint256 a, uint256 b) → bool success, uint256 result++` [.item-kind]#internal# -Returns the subtraction of two unsigned integers, with an success flag (no overflow). +Returns the subtraction of two unsigned integers, with a success flag (no overflow). [.contract-item] [[Math-tryMul-uint256-uint256-]] ==== `[.contract-item-name]#++tryMul++#++(uint256 a, uint256 b) → bool success, uint256 result++` [.item-kind]#internal# -Returns the multiplication of two unsigned integers, with an success flag (no overflow). +Returns the multiplication of two unsigned integers, with a success flag (no overflow). [.contract-item] [[Math-tryDiv-uint256-uint256-]] @@ -937,6 +1050,24 @@ Returns the division of two unsigned integers, with a success flag (no division Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero). +[.contract-item] +[[Math-saturatingAdd-uint256-uint256-]] +==== `[.contract-item-name]#++saturatingAdd++#++(uint256 a, uint256 b) → uint256++` [.item-kind]#internal# + +Unsigned saturating addition, bounds to `2²⁵⁶ - 1` instead of overflowing. + +[.contract-item] +[[Math-saturatingSub-uint256-uint256-]] +==== `[.contract-item-name]#++saturatingSub++#++(uint256 a, uint256 b) → uint256++` [.item-kind]#internal# + +Unsigned saturating subtraction, bounds to zero instead of overflowing. + +[.contract-item] +[[Math-saturatingMul-uint256-uint256-]] +==== `[.contract-item-name]#++saturatingMul++#++(uint256 a, uint256 b) → uint256++` [.item-kind]#internal# + +Unsigned saturating multiplication, bounds to `2²⁵⁶ - 1` instead of overflowing. + [.contract-item] [[Math-ternary-bool-uint256-uint256-]] ==== `[.contract-item-name]#++ternary++#++(bool condition, uint256 a, uint256 b) → uint256++` [.item-kind]#internal# @@ -991,6 +1122,18 @@ Uniswap Labs also under MIT license. Calculates x * y / denominator with full precision, following the selected rounding direction. +[.contract-item] +[[Math-mulShr-uint256-uint256-uint8-]] +==== `[.contract-item-name]#++mulShr++#++(uint256 x, uint256 y, uint8 n) → uint256 result++` [.item-kind]#internal# + +Calculates floor(x * y >> n) with full precision. Throws if result overflows a uint256. + +[.contract-item] +[[Math-mulShr-uint256-uint256-uint8-enum-Math-Rounding-]] +==== `[.contract-item-name]#++mulShr++#++(uint256 x, uint256 y, uint8 n, enum Math.Rounding rounding) → uint256++` [.item-kind]#internal# + +Calculates x * y >> n with full precision, following the selected rounding direction. + [.contract-item] [[Math-invMod-uint256-uint256-]] ==== `[.contract-item-name]#++invMod++#++(uint256 a, uint256 n) → uint256++` [.item-kind]#internal# @@ -1076,7 +1219,7 @@ Calculates sqrt(a), following the selected rounding direction. [.contract-item] [[Math-log2-uint256-]] -==== `[.contract-item-name]#++log2++#++(uint256 value) → uint256++` [.item-kind]#internal# +==== `[.contract-item-name]#++log2++#++(uint256 x) → uint256 r++` [.item-kind]#internal# Return the log in base 2 of a positive value rounded towards zero. Returns 0 if given 0. @@ -1104,7 +1247,7 @@ Returns 0 if given 0. [.contract-item] [[Math-log256-uint256-]] -==== `[.contract-item-name]#++log256++#++(uint256 value) → uint256++` [.item-kind]#internal# +==== `[.contract-item-name]#++log256++#++(uint256 x) → uint256 r++` [.item-kind]#internal# Return the log in base 256 of a positive value rounded towards zero. Returns 0 if given 0. @@ -1130,9 +1273,15 @@ Returns whether a provided rounding mode is considered rounding up for unsigned :average: pass:normal[xref:#SignedMath-average-int256-int256-[`++average++`]] :abs: pass:normal[xref:#SignedMath-abs-int256-[`++abs++`]] +:ternary-bool-int256-int256: pass:normal[xref:#SignedMath-ternary-bool-int256-int256-[`++ternary++`]] +:max-int256-int256: pass:normal[xref:#SignedMath-max-int256-int256-[`++max++`]] +:min-int256-int256: pass:normal[xref:#SignedMath-min-int256-int256-[`++min++`]] +:average-int256-int256: pass:normal[xref:#SignedMath-average-int256-int256-[`++average++`]] +:abs-int256: pass:normal[xref:#SignedMath-abs-int256-[`++abs++`]] + [.contract] [[SignedMath]] -=== `++SignedMath++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/math/SignedMath.sol[{github-icon},role=heading-link] +=== `++SignedMath++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/math/SignedMath.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -1257,9 +1406,75 @@ Returns the absolute unsigned value of a signed value. :toInt256: pass:normal[xref:#SafeCast-toInt256-uint256-[`++toInt256++`]] :toUint: pass:normal[xref:#SafeCast-toUint-bool-[`++toUint++`]] +:toUint248-uint256: pass:normal[xref:#SafeCast-toUint248-uint256-[`++toUint248++`]] +:toUint240-uint256: pass:normal[xref:#SafeCast-toUint240-uint256-[`++toUint240++`]] +:toUint232-uint256: pass:normal[xref:#SafeCast-toUint232-uint256-[`++toUint232++`]] +:toUint224-uint256: pass:normal[xref:#SafeCast-toUint224-uint256-[`++toUint224++`]] +:toUint216-uint256: pass:normal[xref:#SafeCast-toUint216-uint256-[`++toUint216++`]] +:toUint208-uint256: pass:normal[xref:#SafeCast-toUint208-uint256-[`++toUint208++`]] +:toUint200-uint256: pass:normal[xref:#SafeCast-toUint200-uint256-[`++toUint200++`]] +:toUint192-uint256: pass:normal[xref:#SafeCast-toUint192-uint256-[`++toUint192++`]] +:toUint184-uint256: pass:normal[xref:#SafeCast-toUint184-uint256-[`++toUint184++`]] +:toUint176-uint256: pass:normal[xref:#SafeCast-toUint176-uint256-[`++toUint176++`]] +:toUint168-uint256: pass:normal[xref:#SafeCast-toUint168-uint256-[`++toUint168++`]] +:toUint160-uint256: pass:normal[xref:#SafeCast-toUint160-uint256-[`++toUint160++`]] +:toUint152-uint256: pass:normal[xref:#SafeCast-toUint152-uint256-[`++toUint152++`]] +:toUint144-uint256: pass:normal[xref:#SafeCast-toUint144-uint256-[`++toUint144++`]] +:toUint136-uint256: pass:normal[xref:#SafeCast-toUint136-uint256-[`++toUint136++`]] +:toUint128-uint256: pass:normal[xref:#SafeCast-toUint128-uint256-[`++toUint128++`]] +:toUint120-uint256: pass:normal[xref:#SafeCast-toUint120-uint256-[`++toUint120++`]] +:toUint112-uint256: pass:normal[xref:#SafeCast-toUint112-uint256-[`++toUint112++`]] +:toUint104-uint256: pass:normal[xref:#SafeCast-toUint104-uint256-[`++toUint104++`]] +:toUint96-uint256: pass:normal[xref:#SafeCast-toUint96-uint256-[`++toUint96++`]] +:toUint88-uint256: pass:normal[xref:#SafeCast-toUint88-uint256-[`++toUint88++`]] +:toUint80-uint256: pass:normal[xref:#SafeCast-toUint80-uint256-[`++toUint80++`]] +:toUint72-uint256: pass:normal[xref:#SafeCast-toUint72-uint256-[`++toUint72++`]] +:toUint64-uint256: pass:normal[xref:#SafeCast-toUint64-uint256-[`++toUint64++`]] +:toUint56-uint256: pass:normal[xref:#SafeCast-toUint56-uint256-[`++toUint56++`]] +:toUint48-uint256: pass:normal[xref:#SafeCast-toUint48-uint256-[`++toUint48++`]] +:toUint40-uint256: pass:normal[xref:#SafeCast-toUint40-uint256-[`++toUint40++`]] +:toUint32-uint256: pass:normal[xref:#SafeCast-toUint32-uint256-[`++toUint32++`]] +:toUint24-uint256: pass:normal[xref:#SafeCast-toUint24-uint256-[`++toUint24++`]] +:toUint16-uint256: pass:normal[xref:#SafeCast-toUint16-uint256-[`++toUint16++`]] +:toUint8-uint256: pass:normal[xref:#SafeCast-toUint8-uint256-[`++toUint8++`]] +:toUint256-int256: pass:normal[xref:#SafeCast-toUint256-int256-[`++toUint256++`]] +:toInt248-int256: pass:normal[xref:#SafeCast-toInt248-int256-[`++toInt248++`]] +:toInt240-int256: pass:normal[xref:#SafeCast-toInt240-int256-[`++toInt240++`]] +:toInt232-int256: pass:normal[xref:#SafeCast-toInt232-int256-[`++toInt232++`]] +:toInt224-int256: pass:normal[xref:#SafeCast-toInt224-int256-[`++toInt224++`]] +:toInt216-int256: pass:normal[xref:#SafeCast-toInt216-int256-[`++toInt216++`]] +:toInt208-int256: pass:normal[xref:#SafeCast-toInt208-int256-[`++toInt208++`]] +:toInt200-int256: pass:normal[xref:#SafeCast-toInt200-int256-[`++toInt200++`]] +:toInt192-int256: pass:normal[xref:#SafeCast-toInt192-int256-[`++toInt192++`]] +:toInt184-int256: pass:normal[xref:#SafeCast-toInt184-int256-[`++toInt184++`]] +:toInt176-int256: pass:normal[xref:#SafeCast-toInt176-int256-[`++toInt176++`]] +:toInt168-int256: pass:normal[xref:#SafeCast-toInt168-int256-[`++toInt168++`]] +:toInt160-int256: pass:normal[xref:#SafeCast-toInt160-int256-[`++toInt160++`]] +:toInt152-int256: pass:normal[xref:#SafeCast-toInt152-int256-[`++toInt152++`]] +:toInt144-int256: pass:normal[xref:#SafeCast-toInt144-int256-[`++toInt144++`]] +:toInt136-int256: pass:normal[xref:#SafeCast-toInt136-int256-[`++toInt136++`]] +:toInt128-int256: pass:normal[xref:#SafeCast-toInt128-int256-[`++toInt128++`]] +:toInt120-int256: pass:normal[xref:#SafeCast-toInt120-int256-[`++toInt120++`]] +:toInt112-int256: pass:normal[xref:#SafeCast-toInt112-int256-[`++toInt112++`]] +:toInt104-int256: pass:normal[xref:#SafeCast-toInt104-int256-[`++toInt104++`]] +:toInt96-int256: pass:normal[xref:#SafeCast-toInt96-int256-[`++toInt96++`]] +:toInt88-int256: pass:normal[xref:#SafeCast-toInt88-int256-[`++toInt88++`]] +:toInt80-int256: pass:normal[xref:#SafeCast-toInt80-int256-[`++toInt80++`]] +:toInt72-int256: pass:normal[xref:#SafeCast-toInt72-int256-[`++toInt72++`]] +:toInt64-int256: pass:normal[xref:#SafeCast-toInt64-int256-[`++toInt64++`]] +:toInt56-int256: pass:normal[xref:#SafeCast-toInt56-int256-[`++toInt56++`]] +:toInt48-int256: pass:normal[xref:#SafeCast-toInt48-int256-[`++toInt48++`]] +:toInt40-int256: pass:normal[xref:#SafeCast-toInt40-int256-[`++toInt40++`]] +:toInt32-int256: pass:normal[xref:#SafeCast-toInt32-int256-[`++toInt32++`]] +:toInt24-int256: pass:normal[xref:#SafeCast-toInt24-int256-[`++toInt24++`]] +:toInt16-int256: pass:normal[xref:#SafeCast-toInt16-int256-[`++toInt16++`]] +:toInt8-int256: pass:normal[xref:#SafeCast-toInt8-int256-[`++toInt8++`]] +:toInt256-uint256: pass:normal[xref:#SafeCast-toInt256-uint256-[`++toInt256++`]] +:toUint-bool: pass:normal[xref:#SafeCast-toUint-bool-[`++toUint++`]] + [.contract] [[SafeCast]] -=== `++SafeCast++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/math/SafeCast.sol[{github-icon},role=heading-link] +=== `++SafeCast++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/math/SafeCast.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2258,9 +2473,16 @@ An uint value doesn't fit in an int of `bits` size. :tryRecover: pass:normal[xref:#ECDSA-tryRecover-bytes32-uint8-bytes32-bytes32-[`++tryRecover++`]] :recover: pass:normal[xref:#ECDSA-recover-bytes32-uint8-bytes32-bytes32-[`++recover++`]] +:tryRecover-bytes32-bytes: pass:normal[xref:#ECDSA-tryRecover-bytes32-bytes-[`++tryRecover++`]] +:recover-bytes32-bytes: pass:normal[xref:#ECDSA-recover-bytes32-bytes-[`++recover++`]] +:tryRecover-bytes32-bytes32-bytes32: pass:normal[xref:#ECDSA-tryRecover-bytes32-bytes32-bytes32-[`++tryRecover++`]] +:recover-bytes32-bytes32-bytes32: pass:normal[xref:#ECDSA-recover-bytes32-bytes32-bytes32-[`++recover++`]] +:tryRecover-bytes32-uint8-bytes32-bytes32: pass:normal[xref:#ECDSA-tryRecover-bytes32-uint8-bytes32-bytes32-[`++tryRecover++`]] +:recover-bytes32-uint8-bytes32-bytes32: pass:normal[xref:#ECDSA-recover-bytes32-uint8-bytes32-bytes32-[`++recover++`]] + [.contract] [[ECDSA]] -=== `++ECDSA++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/ECDSA.sol[{github-icon},role=heading-link] +=== `++ECDSA++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/ECDSA.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2393,9 +2615,15 @@ The signature has an S value that is in the upper half order. :recovery: pass:normal[xref:#P256-recovery-bytes32-uint8-bytes32-bytes32-[`++recovery++`]] :isValidPublicKey: pass:normal[xref:#P256-isValidPublicKey-bytes32-bytes32-[`++isValidPublicKey++`]] +:verify-bytes32-bytes32-bytes32-bytes32-bytes32: pass:normal[xref:#P256-verify-bytes32-bytes32-bytes32-bytes32-bytes32-[`++verify++`]] +:verifyNative-bytes32-bytes32-bytes32-bytes32-bytes32: pass:normal[xref:#P256-verifyNative-bytes32-bytes32-bytes32-bytes32-bytes32-[`++verifyNative++`]] +:verifySolidity-bytes32-bytes32-bytes32-bytes32-bytes32: pass:normal[xref:#P256-verifySolidity-bytes32-bytes32-bytes32-bytes32-bytes32-[`++verifySolidity++`]] +:recovery-bytes32-uint8-bytes32-bytes32: pass:normal[xref:#P256-recovery-bytes32-uint8-bytes32-bytes32-[`++recovery++`]] +:isValidPublicKey-bytes32-bytes32: pass:normal[xref:#P256-isValidPublicKey-bytes32-bytes32-[`++isValidPublicKey++`]] + [.contract] [[P256]] -=== `++P256++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/P256.sol[{github-icon},role=heading-link] +=== `++P256++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/P256.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2512,9 +2740,12 @@ B parameter of the weierstrass equation :pkcs1Sha256: pass:normal[xref:#RSA-pkcs1Sha256-bytes-bytes-bytes-bytes-[`++pkcs1Sha256++`]] :pkcs1Sha256: pass:normal[xref:#RSA-pkcs1Sha256-bytes32-bytes-bytes-bytes-[`++pkcs1Sha256++`]] +:pkcs1Sha256-bytes-bytes-bytes-bytes: pass:normal[xref:#RSA-pkcs1Sha256-bytes-bytes-bytes-bytes-[`++pkcs1Sha256++`]] +:pkcs1Sha256-bytes32-bytes-bytes-bytes: pass:normal[xref:#RSA-pkcs1Sha256-bytes32-bytes-bytes-bytes-[`++pkcs1Sha256++`]] + [.contract] [[RSA]] -=== `++RSA++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/RSA.sol[{github-icon},role=heading-link] +=== `++RSA++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/RSA.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2571,9 +2802,16 @@ using a low exponent out of security concerns. :_EIP712Name: pass:normal[xref:#EIP712-_EIP712Name--[`++_EIP712Name++`]] :_EIP712Version: pass:normal[xref:#EIP712-_EIP712Version--[`++_EIP712Version++`]] +:constructor-string-string: pass:normal[xref:#EIP712-constructor-string-string-[`++constructor++`]] +:_domainSeparatorV4-: pass:normal[xref:#EIP712-_domainSeparatorV4--[`++_domainSeparatorV4++`]] +:_hashTypedDataV4-bytes32: pass:normal[xref:#EIP712-_hashTypedDataV4-bytes32-[`++_hashTypedDataV4++`]] +:eip712Domain-: pass:normal[xref:#EIP712-eip712Domain--[`++eip712Domain++`]] +:_EIP712Name-: pass:normal[xref:#EIP712-_EIP712Name--[`++_EIP712Name++`]] +:_EIP712Version-: pass:normal[xref:#EIP712-_EIP712Version--[`++_EIP712Version++`]] + [.contract] [[EIP712]] -=== `++EIP712++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/EIP712.sol[{github-icon},role=heading-link] +=== `++EIP712++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/EIP712.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2669,7 +2907,8 @@ address signer = ECDSA.recover(digest, signature); [[EIP712-eip712Domain--]] ==== `[.contract-item-name]#++eip712Domain++#++() → bytes1 fields, string name, string version, uint256 chainId, address verifyingContract, bytes32 salt, uint256[] extensions++` [.item-kind]#public# -See {IERC-5267}. +returns the fields and values that describe the domain separator used by this contract for EIP-712 +signature. [.contract-item] [[EIP712-_EIP712Name--]] @@ -2692,11 +2931,18 @@ It only reads from storage if necessary (in case the value is too large to fit i :toEthSignedMessageHash: pass:normal[xref:#MessageHashUtils-toEthSignedMessageHash-bytes32-[`++toEthSignedMessageHash++`]] :toEthSignedMessageHash: pass:normal[xref:#MessageHashUtils-toEthSignedMessageHash-bytes-[`++toEthSignedMessageHash++`]] :toDataWithIntendedValidatorHash: pass:normal[xref:#MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes-[`++toDataWithIntendedValidatorHash++`]] +:toDataWithIntendedValidatorHash: pass:normal[xref:#MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes32-[`++toDataWithIntendedValidatorHash++`]] :toTypedDataHash: pass:normal[xref:#MessageHashUtils-toTypedDataHash-bytes32-bytes32-[`++toTypedDataHash++`]] +:toEthSignedMessageHash-bytes32: pass:normal[xref:#MessageHashUtils-toEthSignedMessageHash-bytes32-[`++toEthSignedMessageHash++`]] +:toEthSignedMessageHash-bytes: pass:normal[xref:#MessageHashUtils-toEthSignedMessageHash-bytes-[`++toEthSignedMessageHash++`]] +:toDataWithIntendedValidatorHash-address-bytes: pass:normal[xref:#MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes-[`++toDataWithIntendedValidatorHash++`]] +:toDataWithIntendedValidatorHash-address-bytes32: pass:normal[xref:#MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes32-[`++toDataWithIntendedValidatorHash++`]] +:toTypedDataHash-bytes32-bytes32: pass:normal[xref:#MessageHashUtils-toTypedDataHash-bytes32-bytes32-[`++toTypedDataHash++`]] + [.contract] [[MessageHashUtils]] -=== `++MessageHashUtils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/MessageHashUtils.sol[{github-icon},role=heading-link] +=== `++MessageHashUtils++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/MessageHashUtils.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2715,6 +2961,7 @@ specifications. * {xref-MessageHashUtils-toEthSignedMessageHash-bytes32-}[`++toEthSignedMessageHash(messageHash)++`] * {xref-MessageHashUtils-toEthSignedMessageHash-bytes-}[`++toEthSignedMessageHash(message)++`] * {xref-MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes-}[`++toDataWithIntendedValidatorHash(validator, data)++`] +* {xref-MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes32-}[`++toDataWithIntendedValidatorHash(validator, messageHash)++`] * {xref-MessageHashUtils-toTypedDataHash-bytes32-bytes32-}[`++toTypedDataHash(domainSeparator, structHash)++`] -- @@ -2728,7 +2975,7 @@ Returns the keccak256 digest of an ERC-191 signed data with version The digest is calculated by prefixing a bytes32 `messageHash` with `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the -hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. +hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method. NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with keccak256, although any bytes32 value can be safely used because the final digest will @@ -2745,7 +2992,7 @@ Returns the keccak256 digest of an ERC-191 signed data with version The digest is calculated by prefixing an arbitrary `message` with `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the -hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method. +hash signed when using the https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sign[`eth_sign`] JSON-RPC method. See {ECDSA-recover}. @@ -2761,6 +3008,12 @@ The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and See {ECDSA-recover}. +[.contract-item] +[[MessageHashUtils-toDataWithIntendedValidatorHash-address-bytes32-]] +==== `[.contract-item-name]#++toDataWithIntendedValidatorHash++#++(address validator, bytes32 messageHash) → bytes32 digest++` [.item-kind]#internal# + +Variant of {toDataWithIntendedValidatorHash-address-bytes} optimized for cases where `data` is a bytes32. + [.contract-item] [[MessageHashUtils-toTypedDataHash-bytes32-bytes32-]] ==== `[.contract-item-name]#++toTypedDataHash++#++(bytes32 domainSeparator, bytes32 structHash) → bytes32 digest++` [.item-kind]#internal# @@ -2776,9 +3029,12 @@ See {ECDSA-recover}. :isValidSignatureNow: pass:normal[xref:#SignatureChecker-isValidSignatureNow-address-bytes32-bytes-[`++isValidSignatureNow++`]] :isValidERC1271SignatureNow: pass:normal[xref:#SignatureChecker-isValidERC1271SignatureNow-address-bytes32-bytes-[`++isValidERC1271SignatureNow++`]] +:isValidSignatureNow-address-bytes32-bytes: pass:normal[xref:#SignatureChecker-isValidSignatureNow-address-bytes32-bytes-[`++isValidSignatureNow++`]] +:isValidERC1271SignatureNow-address-bytes32-bytes: pass:normal[xref:#SignatureChecker-isValidERC1271SignatureNow-address-bytes32-bytes-[`++isValidERC1271SignatureNow++`]] + [.contract] [[SignatureChecker]] -=== `++SignatureChecker++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/SignatureChecker.sol[{github-icon},role=heading-link] +=== `++SignatureChecker++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/SignatureChecker.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2818,10 +3074,14 @@ NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcom change through time. It could return true at block N and false at block N+1 (or the opposite). :commutativeKeccak256: pass:normal[xref:#Hashes-commutativeKeccak256-bytes32-bytes32-[`++commutativeKeccak256++`]] +:efficientKeccak256: pass:normal[xref:#Hashes-efficientKeccak256-bytes32-bytes32-[`++efficientKeccak256++`]] + +:commutativeKeccak256-bytes32-bytes32: pass:normal[xref:#Hashes-commutativeKeccak256-bytes32-bytes32-[`++commutativeKeccak256++`]] +:efficientKeccak256-bytes32-bytes32: pass:normal[xref:#Hashes-efficientKeccak256-bytes32-bytes32-[`++efficientKeccak256++`]] [.contract] [[Hashes]] -=== `++Hashes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/Hashes.sol[{github-icon},role=heading-link] +=== `++Hashes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/Hashes.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -2836,6 +3096,7 @@ _Available since v5.1._ .Functions -- * {xref-Hashes-commutativeKeccak256-bytes32-bytes32-}[`++commutativeKeccak256(a, b)++`] +* {xref-Hashes-efficientKeccak256-bytes32-bytes32-}[`++efficientKeccak256(a, b)++`] -- @@ -2847,6 +3108,12 @@ Commutative Keccak256 hash of a sorted pair of bytes32. Frequently used when wor NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppelin/merkle-tree[JavaScript library]. +[.contract-item] +[[Hashes-efficientKeccak256-bytes32-bytes32-]] +==== `[.contract-item-name]#++efficientKeccak256++#++(bytes32 a, bytes32 b) → bytes32 value++` [.item-kind]#internal# + +Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory. + :MerkleProofInvalidMultiproof: pass:normal[xref:#MerkleProof-MerkleProofInvalidMultiproof--[`++MerkleProofInvalidMultiproof++`]] :verify: pass:normal[xref:#MerkleProof-verify-bytes32---bytes32-bytes32-[`++verify++`]] :processProof: pass:normal[xref:#MerkleProof-processProof-bytes32---bytes32-[`++processProof++`]] @@ -2865,9 +3132,26 @@ NOTE: Equivalent to the `standardNodeHash` in our https://github.com/OpenZeppeli :multiProofVerifyCalldata: pass:normal[xref:#MerkleProof-multiProofVerifyCalldata-bytes32---bool---bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++multiProofVerifyCalldata++`]] :processMultiProofCalldata: pass:normal[xref:#MerkleProof-processMultiProofCalldata-bytes32---bool---bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++processMultiProofCalldata++`]] +:verify-bytes32---bytes32-bytes32: pass:normal[xref:#MerkleProof-verify-bytes32---bytes32-bytes32-[`++verify++`]] +:processProof-bytes32---bytes32: pass:normal[xref:#MerkleProof-processProof-bytes32---bytes32-[`++processProof++`]] +:verify-bytes32---bytes32-bytes32-function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-verify-bytes32---bytes32-bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++verify++`]] +:processProof-bytes32---bytes32-function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-processProof-bytes32---bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++processProof++`]] +:verifyCalldata-bytes32---bytes32-bytes32: pass:normal[xref:#MerkleProof-verifyCalldata-bytes32---bytes32-bytes32-[`++verifyCalldata++`]] +:processProofCalldata-bytes32---bytes32: pass:normal[xref:#MerkleProof-processProofCalldata-bytes32---bytes32-[`++processProofCalldata++`]] +:verifyCalldata-bytes32---bytes32-bytes32-function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-verifyCalldata-bytes32---bytes32-bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++verifyCalldata++`]] +:processProofCalldata-bytes32---bytes32-function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-processProofCalldata-bytes32---bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++processProofCalldata++`]] +:multiProofVerify-bytes32---bool---bytes32-bytes32--: pass:normal[xref:#MerkleProof-multiProofVerify-bytes32---bool---bytes32-bytes32---[`++multiProofVerify++`]] +:processMultiProof-bytes32---bool---bytes32--: pass:normal[xref:#MerkleProof-processMultiProof-bytes32---bool---bytes32---[`++processMultiProof++`]] +:multiProofVerify-bytes32---bool---bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-multiProofVerify-bytes32---bool---bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++multiProofVerify++`]] +:processMultiProof-bytes32---bool---bytes32---function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-processMultiProof-bytes32---bool---bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++processMultiProof++`]] +:multiProofVerifyCalldata-bytes32---bool---bytes32-bytes32--: pass:normal[xref:#MerkleProof-multiProofVerifyCalldata-bytes32---bool---bytes32-bytes32---[`++multiProofVerifyCalldata++`]] +:processMultiProofCalldata-bytes32---bool---bytes32--: pass:normal[xref:#MerkleProof-processMultiProofCalldata-bytes32---bool---bytes32---[`++processMultiProofCalldata++`]] +:multiProofVerifyCalldata-bytes32---bool---bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-multiProofVerifyCalldata-bytes32---bool---bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++multiProofVerifyCalldata++`]] +:processMultiProofCalldata-bytes32---bool---bytes32---function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleProof-processMultiProofCalldata-bytes32---bool---bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++processMultiProofCalldata++`]] + [.contract] [[MerkleProof]] -=== `++MerkleProof++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/cryptography/MerkleProof.sol[{github-icon},role=heading-link] +=== `++MerkleProof++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/cryptography/MerkleProof.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3157,9 +3441,12 @@ The multiproof provided is not valid. :nonReentrant: pass:normal[xref:#ReentrancyGuard-nonReentrant--[`++nonReentrant++`]] :_reentrancyGuardEntered: pass:normal[xref:#ReentrancyGuard-_reentrancyGuardEntered--[`++_reentrancyGuardEntered++`]] +:constructor-: pass:normal[xref:#ReentrancyGuard-constructor--[`++constructor++`]] +:_reentrancyGuardEntered-: pass:normal[xref:#ReentrancyGuard-_reentrancyGuardEntered--[`++_reentrancyGuardEntered++`]] + [.contract] [[ReentrancyGuard]] -=== `++ReentrancyGuard++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/ReentrancyGuard.sol[{github-icon},role=heading-link] +=== `++ReentrancyGuard++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/ReentrancyGuard.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3236,9 +3523,11 @@ Unauthorized reentrant call. :nonReentrant: pass:normal[xref:#ReentrancyGuardTransient-nonReentrant--[`++nonReentrant++`]] :_reentrancyGuardEntered: pass:normal[xref:#ReentrancyGuardTransient-_reentrancyGuardEntered--[`++_reentrancyGuardEntered++`]] +:_reentrancyGuardEntered-: pass:normal[xref:#ReentrancyGuardTransient-_reentrancyGuardEntered--[`++_reentrancyGuardEntered++`]] + [.contract] [[ReentrancyGuardTransient]] -=== `++ReentrancyGuardTransient++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/ReentrancyGuardTransient.sol[{github-icon},role=heading-link] +=== `++ReentrancyGuardTransient++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/ReentrancyGuardTransient.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3298,7 +3587,6 @@ Unauthorized reentrant call. :Unpaused: pass:normal[xref:#Pausable-Unpaused-address-[`++Unpaused++`]] :EnforcedPause: pass:normal[xref:#Pausable-EnforcedPause--[`++EnforcedPause++`]] :ExpectedPause: pass:normal[xref:#Pausable-ExpectedPause--[`++ExpectedPause++`]] -:constructor: pass:normal[xref:#Pausable-constructor--[`++constructor++`]] :whenNotPaused: pass:normal[xref:#Pausable-whenNotPaused--[`++whenNotPaused++`]] :whenPaused: pass:normal[xref:#Pausable-whenPaused--[`++whenPaused++`]] :paused: pass:normal[xref:#Pausable-paused--[`++paused++`]] @@ -3307,9 +3595,15 @@ Unauthorized reentrant call. :_pause: pass:normal[xref:#Pausable-_pause--[`++_pause++`]] :_unpause: pass:normal[xref:#Pausable-_unpause--[`++_unpause++`]] +:paused-: pass:normal[xref:#Pausable-paused--[`++paused++`]] +:_requireNotPaused-: pass:normal[xref:#Pausable-_requireNotPaused--[`++_requireNotPaused++`]] +:_requirePaused-: pass:normal[xref:#Pausable-_requirePaused--[`++_requirePaused++`]] +:_pause-: pass:normal[xref:#Pausable-_pause--[`++_pause++`]] +:_unpause-: pass:normal[xref:#Pausable-_unpause--[`++_unpause++`]] + [.contract] [[Pausable]] -=== `++Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Pausable.sol[{github-icon},role=heading-link] +=== `++Pausable++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Pausable.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3334,7 +3628,6 @@ simply including this module, only once the modifiers are put in place. [.contract-index] .Functions -- -* {xref-Pausable-constructor--}[`++constructor()++`] * {xref-Pausable-paused--}[`++paused()++`] * {xref-Pausable-_requireNotPaused--}[`++_requireNotPaused()++`] * {xref-Pausable-_requirePaused--}[`++_requirePaused()++`] @@ -3379,12 +3672,6 @@ Requirements: - The contract must be paused. -[.contract-item] -[[Pausable-constructor--]] -==== `[.contract-item-name]#++constructor++#++()++` [.item-kind]#internal# - -Initializes the contract in unpaused state. - [.contract-item] [[Pausable-paused--]] ==== `[.contract-item-name]#++paused++#++() → bool++` [.item-kind]#public# @@ -3452,9 +3739,13 @@ The operation failed because the contract is not paused. :_useNonce: pass:normal[xref:#Nonces-_useNonce-address-[`++_useNonce++`]] :_useCheckedNonce: pass:normal[xref:#Nonces-_useCheckedNonce-address-uint256-[`++_useCheckedNonce++`]] +:nonces-address: pass:normal[xref:#Nonces-nonces-address-[`++nonces++`]] +:_useNonce-address: pass:normal[xref:#Nonces-_useNonce-address-[`++_useNonce++`]] +:_useCheckedNonce-address-uint256: pass:normal[xref:#Nonces-_useCheckedNonce-address-uint256-[`++_useCheckedNonce++`]] + [.contract] [[Nonces]] -=== `++Nonces++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Nonces.sol[{github-icon},role=heading-link] +=== `++Nonces++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Nonces.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3510,9 +3801,14 @@ The nonce used for an `account` is not the expected current nonce. :_useCheckedNonce: pass:normal[xref:#NoncesKeyed-_useCheckedNonce-address-uint256-[`++_useCheckedNonce++`]] :_useCheckedNonce: pass:normal[xref:#NoncesKeyed-_useCheckedNonce-address-uint192-uint64-[`++_useCheckedNonce++`]] +:nonces-address-uint192: pass:normal[xref:#NoncesKeyed-nonces-address-uint192-[`++nonces++`]] +:_useNonce-address-uint192: pass:normal[xref:#NoncesKeyed-_useNonce-address-uint192-[`++_useNonce++`]] +:_useCheckedNonce-address-uint256: pass:normal[xref:#NoncesKeyed-_useCheckedNonce-address-uint256-[`++_useCheckedNonce++`]] +:_useCheckedNonce-address-uint192-uint64: pass:normal[xref:#NoncesKeyed-_useCheckedNonce-address-uint192-uint64-[`++_useCheckedNonce++`]] + [.contract] [[NoncesKeyed]] -=== `++NoncesKeyed++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/NoncesKeyed.sol[{github-icon},role=heading-link] +=== `++NoncesKeyed++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/NoncesKeyed.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3593,9 +3889,11 @@ Ethereum contracts have no native concept of an interface, so applications must :supportsInterface: pass:normal[xref:#IERC165-supportsInterface-bytes4-[`++supportsInterface++`]] +:supportsInterface-bytes4: pass:normal[xref:#IERC165-supportsInterface-bytes4-[`++supportsInterface++`]] + [.contract] [[IERC165]] -=== `++IERC165++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/introspection/IERC165.sol[{github-icon},role=heading-link] +=== `++IERC165++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/introspection/IERC165.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3630,9 +3928,11 @@ This function call must use less than 30 000 gas. :supportsInterface: pass:normal[xref:#ERC165-supportsInterface-bytes4-[`++supportsInterface++`]] +:supportsInterface-bytes4: pass:normal[xref:#ERC165-supportsInterface-bytes4-[`++supportsInterface++`]] + [.contract] [[ERC165]] -=== `++ERC165++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/introspection/ERC165.sol[{github-icon},role=heading-link] +=== `++ERC165++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/introspection/ERC165.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3672,9 +3972,15 @@ See {IERC165-supportsInterface}. :supportsAllInterfaces: pass:normal[xref:#ERC165Checker-supportsAllInterfaces-address-bytes4---[`++supportsAllInterfaces++`]] :supportsERC165InterfaceUnchecked: pass:normal[xref:#ERC165Checker-supportsERC165InterfaceUnchecked-address-bytes4-[`++supportsERC165InterfaceUnchecked++`]] +:supportsERC165-address: pass:normal[xref:#ERC165Checker-supportsERC165-address-[`++supportsERC165++`]] +:supportsInterface-address-bytes4: pass:normal[xref:#ERC165Checker-supportsInterface-address-bytes4-[`++supportsInterface++`]] +:getSupportedInterfaces-address-bytes4--: pass:normal[xref:#ERC165Checker-getSupportedInterfaces-address-bytes4---[`++getSupportedInterfaces++`]] +:supportsAllInterfaces-address-bytes4--: pass:normal[xref:#ERC165Checker-supportsAllInterfaces-address-bytes4---[`++supportsAllInterfaces++`]] +:supportsERC165InterfaceUnchecked-address-bytes4: pass:normal[xref:#ERC165Checker-supportsERC165InterfaceUnchecked-address-bytes4-[`++supportsERC165InterfaceUnchecked++`]] + [.contract] [[ERC165Checker]] -=== `++ERC165Checker++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/introspection/ERC165Checker.sol[{github-icon},role=heading-link] +=== `++ERC165Checker++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/introspection/ERC165Checker.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3757,9 +4063,14 @@ Interface identification is specified in ERC-165. :set: pass:normal[xref:#BitMaps-set-struct-BitMaps-BitMap-uint256-[`++set++`]] :unset: pass:normal[xref:#BitMaps-unset-struct-BitMaps-BitMap-uint256-[`++unset++`]] +:get-struct-BitMaps-BitMap-uint256: pass:normal[xref:#BitMaps-get-struct-BitMaps-BitMap-uint256-[`++get++`]] +:setTo-struct-BitMaps-BitMap-uint256-bool: pass:normal[xref:#BitMaps-setTo-struct-BitMaps-BitMap-uint256-bool-[`++setTo++`]] +:set-struct-BitMaps-BitMap-uint256: pass:normal[xref:#BitMaps-set-struct-BitMaps-BitMap-uint256-[`++set++`]] +:unset-struct-BitMaps-BitMap-uint256: pass:normal[xref:#BitMaps-unset-struct-BitMaps-BitMap-uint256-[`++unset++`]] + [.contract] [[BitMaps]] -=== `++BitMaps++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/BitMaps.sol[{github-icon},role=heading-link] +=== `++BitMaps++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/BitMaps.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3816,6 +4127,7 @@ Unsets the bit at `index`. :Bytes32ToBytes32Map: pass:normal[xref:#EnumerableMap-Bytes32ToBytes32Map[`++Bytes32ToBytes32Map++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-bytes32-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToBytes32Map-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-Bytes32ToBytes32Map-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-Bytes32ToBytes32Map-uint256-[`++at++`]] @@ -3825,6 +4137,7 @@ Unsets the bit at `index`. :UintToUintMap: pass:normal[xref:#EnumerableMap-UintToUintMap[`++UintToUintMap++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-UintToUintMap-uint256-uint256-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-UintToUintMap-uint256-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-UintToUintMap-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-UintToUintMap-uint256-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-UintToUintMap-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-UintToUintMap-uint256-[`++at++`]] @@ -3834,6 +4147,7 @@ Unsets the bit at `index`. :UintToAddressMap: pass:normal[xref:#EnumerableMap-UintToAddressMap[`++UintToAddressMap++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-UintToAddressMap-uint256-address-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-UintToAddressMap-uint256-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-UintToAddressMap-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-UintToAddressMap-uint256-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-UintToAddressMap-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-UintToAddressMap-uint256-[`++at++`]] @@ -3843,6 +4157,7 @@ Unsets the bit at `index`. :UintToBytes32Map: pass:normal[xref:#EnumerableMap-UintToBytes32Map[`++UintToBytes32Map++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-UintToBytes32Map-uint256-bytes32-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-UintToBytes32Map-uint256-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-UintToBytes32Map-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-UintToBytes32Map-uint256-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-UintToBytes32Map-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-UintToBytes32Map-uint256-[`++at++`]] @@ -3852,6 +4167,7 @@ Unsets the bit at `index`. :AddressToUintMap: pass:normal[xref:#EnumerableMap-AddressToUintMap[`++AddressToUintMap++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-AddressToUintMap-address-uint256-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-AddressToUintMap-address-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-AddressToUintMap-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-AddressToUintMap-address-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-AddressToUintMap-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-AddressToUintMap-uint256-[`++at++`]] @@ -3861,6 +4177,7 @@ Unsets the bit at `index`. :AddressToAddressMap: pass:normal[xref:#EnumerableMap-AddressToAddressMap[`++AddressToAddressMap++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-AddressToAddressMap-address-address-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-AddressToAddressMap-address-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-AddressToAddressMap-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-AddressToAddressMap-address-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-AddressToAddressMap-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-AddressToAddressMap-uint256-[`++at++`]] @@ -3870,6 +4187,7 @@ Unsets the bit at `index`. :AddressToBytes32Map: pass:normal[xref:#EnumerableMap-AddressToBytes32Map[`++AddressToBytes32Map++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-AddressToBytes32Map-address-bytes32-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-AddressToBytes32Map-address-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-AddressToBytes32Map-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-AddressToBytes32Map-address-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-AddressToBytes32Map-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-AddressToBytes32Map-uint256-[`++at++`]] @@ -3879,6 +4197,7 @@ Unsets the bit at `index`. :Bytes32ToUintMap: pass:normal[xref:#EnumerableMap-Bytes32ToUintMap[`++Bytes32ToUintMap++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-Bytes32ToUintMap-bytes32-uint256-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToUintMap-bytes32-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToUintMap-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-Bytes32ToUintMap-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-Bytes32ToUintMap-uint256-[`++at++`]] @@ -3888,6 +4207,7 @@ Unsets the bit at `index`. :Bytes32ToAddressMap: pass:normal[xref:#EnumerableMap-Bytes32ToAddressMap[`++Bytes32ToAddressMap++`]] :set: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-address-[`++set++`]] :remove: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToAddressMap-[`++clear++`]] :contains: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++contains++`]] :length: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-Bytes32ToAddressMap-[`++length++`]] :at: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-Bytes32ToAddressMap-uint256-[`++at++`]] @@ -3895,9 +4215,91 @@ Unsets the bit at `index`. :get: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++get++`]] :keys: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-Bytes32ToAddressMap-[`++keys++`]] +:set-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-bytes32: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-bytes32-[`++set++`]] +:remove-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-[`++remove++`]] +:clear-struct-EnumerableMap-Bytes32ToBytes32Map: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToBytes32Map-[`++clear++`]] +:contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-[`++contains++`]] +:length-struct-EnumerableMap-Bytes32ToBytes32Map: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-Bytes32ToBytes32Map-[`++length++`]] +:at-struct-EnumerableMap-Bytes32ToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-Bytes32ToBytes32Map-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-[`++tryGet++`]] +:get-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-[`++get++`]] +:keys-struct-EnumerableMap-Bytes32ToBytes32Map: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-Bytes32ToBytes32Map-[`++keys++`]] +:set-struct-EnumerableMap-UintToUintMap-uint256-uint256: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-UintToUintMap-uint256-uint256-[`++set++`]] +:remove-struct-EnumerableMap-UintToUintMap-uint256: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-UintToUintMap-uint256-[`++remove++`]] +:clear-struct-EnumerableMap-UintToUintMap: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-UintToUintMap-[`++clear++`]] +:contains-struct-EnumerableMap-UintToUintMap-uint256: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-UintToUintMap-uint256-[`++contains++`]] +:length-struct-EnumerableMap-UintToUintMap: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-UintToUintMap-[`++length++`]] +:at-struct-EnumerableMap-UintToUintMap-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-UintToUintMap-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-UintToUintMap-uint256: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-UintToUintMap-uint256-[`++tryGet++`]] +:get-struct-EnumerableMap-UintToUintMap-uint256: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-UintToUintMap-uint256-[`++get++`]] +:keys-struct-EnumerableMap-UintToUintMap: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-UintToUintMap-[`++keys++`]] +:set-struct-EnumerableMap-UintToAddressMap-uint256-address: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-UintToAddressMap-uint256-address-[`++set++`]] +:remove-struct-EnumerableMap-UintToAddressMap-uint256: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-UintToAddressMap-uint256-[`++remove++`]] +:clear-struct-EnumerableMap-UintToAddressMap: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-UintToAddressMap-[`++clear++`]] +:contains-struct-EnumerableMap-UintToAddressMap-uint256: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-UintToAddressMap-uint256-[`++contains++`]] +:length-struct-EnumerableMap-UintToAddressMap: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-UintToAddressMap-[`++length++`]] +:at-struct-EnumerableMap-UintToAddressMap-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-UintToAddressMap-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-UintToAddressMap-uint256: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-UintToAddressMap-uint256-[`++tryGet++`]] +:get-struct-EnumerableMap-UintToAddressMap-uint256: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-UintToAddressMap-uint256-[`++get++`]] +:keys-struct-EnumerableMap-UintToAddressMap: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-UintToAddressMap-[`++keys++`]] +:set-struct-EnumerableMap-UintToBytes32Map-uint256-bytes32: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-UintToBytes32Map-uint256-bytes32-[`++set++`]] +:remove-struct-EnumerableMap-UintToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-UintToBytes32Map-uint256-[`++remove++`]] +:clear-struct-EnumerableMap-UintToBytes32Map: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-UintToBytes32Map-[`++clear++`]] +:contains-struct-EnumerableMap-UintToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-UintToBytes32Map-uint256-[`++contains++`]] +:length-struct-EnumerableMap-UintToBytes32Map: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-UintToBytes32Map-[`++length++`]] +:at-struct-EnumerableMap-UintToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-UintToBytes32Map-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-UintToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-UintToBytes32Map-uint256-[`++tryGet++`]] +:get-struct-EnumerableMap-UintToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-UintToBytes32Map-uint256-[`++get++`]] +:keys-struct-EnumerableMap-UintToBytes32Map: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-UintToBytes32Map-[`++keys++`]] +:set-struct-EnumerableMap-AddressToUintMap-address-uint256: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-AddressToUintMap-address-uint256-[`++set++`]] +:remove-struct-EnumerableMap-AddressToUintMap-address: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-AddressToUintMap-address-[`++remove++`]] +:clear-struct-EnumerableMap-AddressToUintMap: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-AddressToUintMap-[`++clear++`]] +:contains-struct-EnumerableMap-AddressToUintMap-address: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-AddressToUintMap-address-[`++contains++`]] +:length-struct-EnumerableMap-AddressToUintMap: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-AddressToUintMap-[`++length++`]] +:at-struct-EnumerableMap-AddressToUintMap-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-AddressToUintMap-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-AddressToUintMap-address: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-AddressToUintMap-address-[`++tryGet++`]] +:get-struct-EnumerableMap-AddressToUintMap-address: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-AddressToUintMap-address-[`++get++`]] +:keys-struct-EnumerableMap-AddressToUintMap: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-AddressToUintMap-[`++keys++`]] +:set-struct-EnumerableMap-AddressToAddressMap-address-address: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-AddressToAddressMap-address-address-[`++set++`]] +:remove-struct-EnumerableMap-AddressToAddressMap-address: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-AddressToAddressMap-address-[`++remove++`]] +:clear-struct-EnumerableMap-AddressToAddressMap: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-AddressToAddressMap-[`++clear++`]] +:contains-struct-EnumerableMap-AddressToAddressMap-address: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-AddressToAddressMap-address-[`++contains++`]] +:length-struct-EnumerableMap-AddressToAddressMap: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-AddressToAddressMap-[`++length++`]] +:at-struct-EnumerableMap-AddressToAddressMap-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-AddressToAddressMap-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-AddressToAddressMap-address: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-AddressToAddressMap-address-[`++tryGet++`]] +:get-struct-EnumerableMap-AddressToAddressMap-address: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-AddressToAddressMap-address-[`++get++`]] +:keys-struct-EnumerableMap-AddressToAddressMap: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-AddressToAddressMap-[`++keys++`]] +:set-struct-EnumerableMap-AddressToBytes32Map-address-bytes32: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-AddressToBytes32Map-address-bytes32-[`++set++`]] +:remove-struct-EnumerableMap-AddressToBytes32Map-address: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-AddressToBytes32Map-address-[`++remove++`]] +:clear-struct-EnumerableMap-AddressToBytes32Map: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-AddressToBytes32Map-[`++clear++`]] +:contains-struct-EnumerableMap-AddressToBytes32Map-address: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-AddressToBytes32Map-address-[`++contains++`]] +:length-struct-EnumerableMap-AddressToBytes32Map: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-AddressToBytes32Map-[`++length++`]] +:at-struct-EnumerableMap-AddressToBytes32Map-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-AddressToBytes32Map-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-AddressToBytes32Map-address: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-AddressToBytes32Map-address-[`++tryGet++`]] +:get-struct-EnumerableMap-AddressToBytes32Map-address: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-AddressToBytes32Map-address-[`++get++`]] +:keys-struct-EnumerableMap-AddressToBytes32Map: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-AddressToBytes32Map-[`++keys++`]] +:set-struct-EnumerableMap-Bytes32ToUintMap-bytes32-uint256: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-Bytes32ToUintMap-bytes32-uint256-[`++set++`]] +:remove-struct-EnumerableMap-Bytes32ToUintMap-bytes32: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToUintMap-bytes32-[`++remove++`]] +:clear-struct-EnumerableMap-Bytes32ToUintMap: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToUintMap-[`++clear++`]] +:contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32-[`++contains++`]] +:length-struct-EnumerableMap-Bytes32ToUintMap: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-Bytes32ToUintMap-[`++length++`]] +:at-struct-EnumerableMap-Bytes32ToUintMap-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-Bytes32ToUintMap-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-Bytes32ToUintMap-bytes32: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-Bytes32ToUintMap-bytes32-[`++tryGet++`]] +:get-struct-EnumerableMap-Bytes32ToUintMap-bytes32: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-Bytes32ToUintMap-bytes32-[`++get++`]] +:keys-struct-EnumerableMap-Bytes32ToUintMap: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-Bytes32ToUintMap-[`++keys++`]] +:set-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-address: pass:normal[xref:#EnumerableMap-set-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-address-[`++set++`]] +:remove-struct-EnumerableMap-Bytes32ToAddressMap-bytes32: pass:normal[xref:#EnumerableMap-remove-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++remove++`]] +:clear-struct-EnumerableMap-Bytes32ToAddressMap: pass:normal[xref:#EnumerableMap-clear-struct-EnumerableMap-Bytes32ToAddressMap-[`++clear++`]] +:contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32: pass:normal[xref:#EnumerableMap-contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++contains++`]] +:length-struct-EnumerableMap-Bytes32ToAddressMap: pass:normal[xref:#EnumerableMap-length-struct-EnumerableMap-Bytes32ToAddressMap-[`++length++`]] +:at-struct-EnumerableMap-Bytes32ToAddressMap-uint256: pass:normal[xref:#EnumerableMap-at-struct-EnumerableMap-Bytes32ToAddressMap-uint256-[`++at++`]] +:tryGet-struct-EnumerableMap-Bytes32ToAddressMap-bytes32: pass:normal[xref:#EnumerableMap-tryGet-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++tryGet++`]] +:get-struct-EnumerableMap-Bytes32ToAddressMap-bytes32: pass:normal[xref:#EnumerableMap-get-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-[`++get++`]] +:keys-struct-EnumerableMap-Bytes32ToAddressMap: pass:normal[xref:#EnumerableMap-keys-struct-EnumerableMap-Bytes32ToAddressMap-[`++keys++`]] + [.contract] [[EnumerableMap]] -=== `++EnumerableMap++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/EnumerableMap.sol[{github-icon},role=heading-link] +=== `++EnumerableMap++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/EnumerableMap.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -3913,6 +4315,7 @@ Maps have the following properties: - Entries are added, removed, and checked for existence in constant time (O(1)). - Entries are enumerated in O(n). No guarantees are made on the ordering. +- Map can be cleared (all entries removed) in O(n). ```solidity contract Example { @@ -3951,6 +4354,7 @@ array of EnumerableMap. -- * {xref-EnumerableMap-set-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-bytes32-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-Bytes32ToBytes32Map-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-Bytes32ToBytes32Map-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-Bytes32ToBytes32Map-uint256-}[`++at(map, index)++`] @@ -3959,6 +4363,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-Bytes32ToBytes32Map-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-UintToUintMap-uint256-uint256-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-UintToUintMap-uint256-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-UintToUintMap-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-UintToUintMap-uint256-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-UintToUintMap-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-UintToUintMap-uint256-}[`++at(map, index)++`] @@ -3967,6 +4372,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-UintToUintMap-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-UintToAddressMap-uint256-address-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-UintToAddressMap-uint256-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-UintToAddressMap-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-UintToAddressMap-uint256-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-UintToAddressMap-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-UintToAddressMap-uint256-}[`++at(map, index)++`] @@ -3975,6 +4381,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-UintToAddressMap-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-UintToBytes32Map-uint256-bytes32-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-UintToBytes32Map-uint256-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-UintToBytes32Map-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-UintToBytes32Map-uint256-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-UintToBytes32Map-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-UintToBytes32Map-uint256-}[`++at(map, index)++`] @@ -3983,6 +4390,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-UintToBytes32Map-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-AddressToUintMap-address-uint256-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-AddressToUintMap-address-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-AddressToUintMap-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-AddressToUintMap-address-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-AddressToUintMap-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-AddressToUintMap-uint256-}[`++at(map, index)++`] @@ -3991,6 +4399,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-AddressToUintMap-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-AddressToAddressMap-address-address-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-AddressToAddressMap-address-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-AddressToAddressMap-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-AddressToAddressMap-address-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-AddressToAddressMap-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-AddressToAddressMap-uint256-}[`++at(map, index)++`] @@ -3999,6 +4408,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-AddressToAddressMap-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-AddressToBytes32Map-address-bytes32-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-AddressToBytes32Map-address-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-AddressToBytes32Map-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-AddressToBytes32Map-address-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-AddressToBytes32Map-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-AddressToBytes32Map-uint256-}[`++at(map, index)++`] @@ -4007,6 +4417,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-AddressToBytes32Map-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-Bytes32ToUintMap-bytes32-uint256-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-Bytes32ToUintMap-bytes32-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-Bytes32ToUintMap-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-Bytes32ToUintMap-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-Bytes32ToUintMap-uint256-}[`++at(map, index)++`] @@ -4015,6 +4426,7 @@ array of EnumerableMap. * {xref-EnumerableMap-keys-struct-EnumerableMap-Bytes32ToUintMap-}[`++keys(map)++`] * {xref-EnumerableMap-set-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-address-}[`++set(map, key, value)++`] * {xref-EnumerableMap-remove-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-}[`++remove(map, key)++`] +* {xref-EnumerableMap-clear-struct-EnumerableMap-Bytes32ToAddressMap-}[`++clear(map)++`] * {xref-EnumerableMap-contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-}[`++contains(map, key)++`] * {xref-EnumerableMap-length-struct-EnumerableMap-Bytes32ToAddressMap-}[`++length(map)++`] * {xref-EnumerableMap-at-struct-EnumerableMap-Bytes32ToAddressMap-uint256-}[`++at(map, index)++`] @@ -4049,6 +4461,15 @@ Removes a key-value pair from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-Bytes32ToBytes32Map-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.Bytes32ToBytes32Map map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-Bytes32ToBytes32Map-bytes32-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.Bytes32ToBytes32Map map, bytes32 key) → bool++` [.item-kind]#internal# @@ -4120,6 +4541,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-UintToUintMap-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.UintToUintMap map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-UintToUintMap-uint256-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.UintToUintMap map, uint256 key) → bool++` [.item-kind]#internal# @@ -4190,6 +4620,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-UintToAddressMap-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.UintToAddressMap map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-UintToAddressMap-uint256-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.UintToAddressMap map, uint256 key) → bool++` [.item-kind]#internal# @@ -4260,6 +4699,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-UintToBytes32Map-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.UintToBytes32Map map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-UintToBytes32Map-uint256-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.UintToBytes32Map map, uint256 key) → bool++` [.item-kind]#internal# @@ -4330,6 +4778,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-AddressToUintMap-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.AddressToUintMap map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-AddressToUintMap-address-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.AddressToUintMap map, address key) → bool++` [.item-kind]#internal# @@ -4400,6 +4857,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-AddressToAddressMap-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.AddressToAddressMap map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-AddressToAddressMap-address-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.AddressToAddressMap map, address key) → bool++` [.item-kind]#internal# @@ -4470,6 +4936,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-AddressToBytes32Map-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.AddressToBytes32Map map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-AddressToBytes32Map-address-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.AddressToBytes32Map map, address key) → bool++` [.item-kind]#internal# @@ -4540,6 +5015,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-Bytes32ToUintMap-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.Bytes32ToUintMap map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-Bytes32ToUintMap-bytes32-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.Bytes32ToUintMap map, bytes32 key) → bool++` [.item-kind]#internal# @@ -4610,6 +5094,15 @@ Removes a value from a map. O(1). Returns true if the key was removed from the map, that is if it was present. +[.contract-item] +[[EnumerableMap-clear-struct-EnumerableMap-Bytes32ToAddressMap-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableMap.Bytes32ToAddressMap map)++` [.item-kind]#internal# + +Removes all the entries from a map. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableMap-contains-struct-EnumerableMap-Bytes32ToAddressMap-bytes32-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableMap.Bytes32ToAddressMap map, bytes32 key) → bool++` [.item-kind]#internal# @@ -4672,6 +5165,7 @@ Query for a nonexistent map key. :Bytes32Set: pass:normal[xref:#EnumerableSet-Bytes32Set[`++Bytes32Set++`]] :add: pass:normal[xref:#EnumerableSet-add-struct-EnumerableSet-Bytes32Set-bytes32-[`++add++`]] :remove: pass:normal[xref:#EnumerableSet-remove-struct-EnumerableSet-Bytes32Set-bytes32-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableSet-clear-struct-EnumerableSet-Bytes32Set-[`++clear++`]] :contains: pass:normal[xref:#EnumerableSet-contains-struct-EnumerableSet-Bytes32Set-bytes32-[`++contains++`]] :length: pass:normal[xref:#EnumerableSet-length-struct-EnumerableSet-Bytes32Set-[`++length++`]] :at: pass:normal[xref:#EnumerableSet-at-struct-EnumerableSet-Bytes32Set-uint256-[`++at++`]] @@ -4679,6 +5173,7 @@ Query for a nonexistent map key. :AddressSet: pass:normal[xref:#EnumerableSet-AddressSet[`++AddressSet++`]] :add: pass:normal[xref:#EnumerableSet-add-struct-EnumerableSet-AddressSet-address-[`++add++`]] :remove: pass:normal[xref:#EnumerableSet-remove-struct-EnumerableSet-AddressSet-address-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableSet-clear-struct-EnumerableSet-AddressSet-[`++clear++`]] :contains: pass:normal[xref:#EnumerableSet-contains-struct-EnumerableSet-AddressSet-address-[`++contains++`]] :length: pass:normal[xref:#EnumerableSet-length-struct-EnumerableSet-AddressSet-[`++length++`]] :at: pass:normal[xref:#EnumerableSet-at-struct-EnumerableSet-AddressSet-uint256-[`++at++`]] @@ -4686,14 +5181,37 @@ Query for a nonexistent map key. :UintSet: pass:normal[xref:#EnumerableSet-UintSet[`++UintSet++`]] :add: pass:normal[xref:#EnumerableSet-add-struct-EnumerableSet-UintSet-uint256-[`++add++`]] :remove: pass:normal[xref:#EnumerableSet-remove-struct-EnumerableSet-UintSet-uint256-[`++remove++`]] +:clear: pass:normal[xref:#EnumerableSet-clear-struct-EnumerableSet-UintSet-[`++clear++`]] :contains: pass:normal[xref:#EnumerableSet-contains-struct-EnumerableSet-UintSet-uint256-[`++contains++`]] :length: pass:normal[xref:#EnumerableSet-length-struct-EnumerableSet-UintSet-[`++length++`]] :at: pass:normal[xref:#EnumerableSet-at-struct-EnumerableSet-UintSet-uint256-[`++at++`]] :values: pass:normal[xref:#EnumerableSet-values-struct-EnumerableSet-UintSet-[`++values++`]] +:add-struct-EnumerableSet-Bytes32Set-bytes32: pass:normal[xref:#EnumerableSet-add-struct-EnumerableSet-Bytes32Set-bytes32-[`++add++`]] +:remove-struct-EnumerableSet-Bytes32Set-bytes32: pass:normal[xref:#EnumerableSet-remove-struct-EnumerableSet-Bytes32Set-bytes32-[`++remove++`]] +:clear-struct-EnumerableSet-Bytes32Set: pass:normal[xref:#EnumerableSet-clear-struct-EnumerableSet-Bytes32Set-[`++clear++`]] +:contains-struct-EnumerableSet-Bytes32Set-bytes32: pass:normal[xref:#EnumerableSet-contains-struct-EnumerableSet-Bytes32Set-bytes32-[`++contains++`]] +:length-struct-EnumerableSet-Bytes32Set: pass:normal[xref:#EnumerableSet-length-struct-EnumerableSet-Bytes32Set-[`++length++`]] +:at-struct-EnumerableSet-Bytes32Set-uint256: pass:normal[xref:#EnumerableSet-at-struct-EnumerableSet-Bytes32Set-uint256-[`++at++`]] +:values-struct-EnumerableSet-Bytes32Set: pass:normal[xref:#EnumerableSet-values-struct-EnumerableSet-Bytes32Set-[`++values++`]] +:add-struct-EnumerableSet-AddressSet-address: pass:normal[xref:#EnumerableSet-add-struct-EnumerableSet-AddressSet-address-[`++add++`]] +:remove-struct-EnumerableSet-AddressSet-address: pass:normal[xref:#EnumerableSet-remove-struct-EnumerableSet-AddressSet-address-[`++remove++`]] +:clear-struct-EnumerableSet-AddressSet: pass:normal[xref:#EnumerableSet-clear-struct-EnumerableSet-AddressSet-[`++clear++`]] +:contains-struct-EnumerableSet-AddressSet-address: pass:normal[xref:#EnumerableSet-contains-struct-EnumerableSet-AddressSet-address-[`++contains++`]] +:length-struct-EnumerableSet-AddressSet: pass:normal[xref:#EnumerableSet-length-struct-EnumerableSet-AddressSet-[`++length++`]] +:at-struct-EnumerableSet-AddressSet-uint256: pass:normal[xref:#EnumerableSet-at-struct-EnumerableSet-AddressSet-uint256-[`++at++`]] +:values-struct-EnumerableSet-AddressSet: pass:normal[xref:#EnumerableSet-values-struct-EnumerableSet-AddressSet-[`++values++`]] +:add-struct-EnumerableSet-UintSet-uint256: pass:normal[xref:#EnumerableSet-add-struct-EnumerableSet-UintSet-uint256-[`++add++`]] +:remove-struct-EnumerableSet-UintSet-uint256: pass:normal[xref:#EnumerableSet-remove-struct-EnumerableSet-UintSet-uint256-[`++remove++`]] +:clear-struct-EnumerableSet-UintSet: pass:normal[xref:#EnumerableSet-clear-struct-EnumerableSet-UintSet-[`++clear++`]] +:contains-struct-EnumerableSet-UintSet-uint256: pass:normal[xref:#EnumerableSet-contains-struct-EnumerableSet-UintSet-uint256-[`++contains++`]] +:length-struct-EnumerableSet-UintSet: pass:normal[xref:#EnumerableSet-length-struct-EnumerableSet-UintSet-[`++length++`]] +:at-struct-EnumerableSet-UintSet-uint256: pass:normal[xref:#EnumerableSet-at-struct-EnumerableSet-UintSet-uint256-[`++at++`]] +:values-struct-EnumerableSet-UintSet: pass:normal[xref:#EnumerableSet-values-struct-EnumerableSet-UintSet-[`++values++`]] + [.contract] [[EnumerableSet]] -=== `++EnumerableSet++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/EnumerableSet.sol[{github-icon},role=heading-link] +=== `++EnumerableSet++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/EnumerableSet.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -4709,6 +5227,7 @@ Sets have the following properties: - Elements are added, removed, and checked for existence in constant time (O(1)). - Elements are enumerated in O(n). No guarantees are made on the ordering. +- Set can be cleared (all elements removed) in O(n). ```solidity contract Example { @@ -4738,18 +5257,21 @@ array of EnumerableSet. -- * {xref-EnumerableSet-add-struct-EnumerableSet-Bytes32Set-bytes32-}[`++add(set, value)++`] * {xref-EnumerableSet-remove-struct-EnumerableSet-Bytes32Set-bytes32-}[`++remove(set, value)++`] +* {xref-EnumerableSet-clear-struct-EnumerableSet-Bytes32Set-}[`++clear(set)++`] * {xref-EnumerableSet-contains-struct-EnumerableSet-Bytes32Set-bytes32-}[`++contains(set, value)++`] * {xref-EnumerableSet-length-struct-EnumerableSet-Bytes32Set-}[`++length(set)++`] * {xref-EnumerableSet-at-struct-EnumerableSet-Bytes32Set-uint256-}[`++at(set, index)++`] * {xref-EnumerableSet-values-struct-EnumerableSet-Bytes32Set-}[`++values(set)++`] * {xref-EnumerableSet-add-struct-EnumerableSet-AddressSet-address-}[`++add(set, value)++`] * {xref-EnumerableSet-remove-struct-EnumerableSet-AddressSet-address-}[`++remove(set, value)++`] +* {xref-EnumerableSet-clear-struct-EnumerableSet-AddressSet-}[`++clear(set)++`] * {xref-EnumerableSet-contains-struct-EnumerableSet-AddressSet-address-}[`++contains(set, value)++`] * {xref-EnumerableSet-length-struct-EnumerableSet-AddressSet-}[`++length(set)++`] * {xref-EnumerableSet-at-struct-EnumerableSet-AddressSet-uint256-}[`++at(set, index)++`] * {xref-EnumerableSet-values-struct-EnumerableSet-AddressSet-}[`++values(set)++`] * {xref-EnumerableSet-add-struct-EnumerableSet-UintSet-uint256-}[`++add(set, value)++`] * {xref-EnumerableSet-remove-struct-EnumerableSet-UintSet-uint256-}[`++remove(set, value)++`] +* {xref-EnumerableSet-clear-struct-EnumerableSet-UintSet-}[`++clear(set)++`] * {xref-EnumerableSet-contains-struct-EnumerableSet-UintSet-uint256-}[`++contains(set, value)++`] * {xref-EnumerableSet-length-struct-EnumerableSet-UintSet-}[`++length(set)++`] * {xref-EnumerableSet-at-struct-EnumerableSet-UintSet-uint256-}[`++at(set, index)++`] @@ -4775,6 +5297,15 @@ Removes a value from a set. O(1). Returns true if the value was removed from the set, that is if it was present. +[.contract-item] +[[EnumerableSet-clear-struct-EnumerableSet-Bytes32Set-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableSet.Bytes32Set set)++` [.item-kind]#internal# + +Removes all the values from a set. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableSet-contains-struct-EnumerableSet-Bytes32Set-bytes32-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableSet.Bytes32Set set, bytes32 value) → bool++` [.item-kind]#internal# @@ -4829,6 +5360,15 @@ Removes a value from a set. O(1). Returns true if the value was removed from the set, that is if it was present. +[.contract-item] +[[EnumerableSet-clear-struct-EnumerableSet-AddressSet-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableSet.AddressSet set)++` [.item-kind]#internal# + +Removes all the values from a set. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableSet-contains-struct-EnumerableSet-AddressSet-address-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableSet.AddressSet set, address value) → bool++` [.item-kind]#internal# @@ -4883,6 +5423,15 @@ Removes a value from a set. O(1). Returns true if the value was removed from the set, that is if it was present. +[.contract-item] +[[EnumerableSet-clear-struct-EnumerableSet-UintSet-]] +==== `[.contract-item-name]#++clear++#++(struct EnumerableSet.UintSet set)++` [.item-kind]#internal# + +Removes all the values from a set. O(n). + +WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the +function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + [.contract-item] [[EnumerableSet-contains-struct-EnumerableSet-UintSet-uint256-]] ==== `[.contract-item-name]#++contains++#++(struct EnumerableSet.UintSet set, uint256 value) → bool++` [.item-kind]#internal# @@ -4931,9 +5480,20 @@ uncallable if the set grows to a point where copying to memory consumes too much :length: pass:normal[xref:#DoubleEndedQueue-length-struct-DoubleEndedQueue-Bytes32Deque-[`++length++`]] :empty: pass:normal[xref:#DoubleEndedQueue-empty-struct-DoubleEndedQueue-Bytes32Deque-[`++empty++`]] +:pushBack-struct-DoubleEndedQueue-Bytes32Deque-bytes32: pass:normal[xref:#DoubleEndedQueue-pushBack-struct-DoubleEndedQueue-Bytes32Deque-bytes32-[`++pushBack++`]] +:popBack-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-popBack-struct-DoubleEndedQueue-Bytes32Deque-[`++popBack++`]] +:pushFront-struct-DoubleEndedQueue-Bytes32Deque-bytes32: pass:normal[xref:#DoubleEndedQueue-pushFront-struct-DoubleEndedQueue-Bytes32Deque-bytes32-[`++pushFront++`]] +:popFront-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-popFront-struct-DoubleEndedQueue-Bytes32Deque-[`++popFront++`]] +:front-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-front-struct-DoubleEndedQueue-Bytes32Deque-[`++front++`]] +:back-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-back-struct-DoubleEndedQueue-Bytes32Deque-[`++back++`]] +:at-struct-DoubleEndedQueue-Bytes32Deque-uint256: pass:normal[xref:#DoubleEndedQueue-at-struct-DoubleEndedQueue-Bytes32Deque-uint256-[`++at++`]] +:clear-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-clear-struct-DoubleEndedQueue-Bytes32Deque-[`++clear++`]] +:length-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-length-struct-DoubleEndedQueue-Bytes32Deque-[`++length++`]] +:empty-struct-DoubleEndedQueue-Bytes32Deque: pass:normal[xref:#DoubleEndedQueue-empty-struct-DoubleEndedQueue-Bytes32Deque-[`++empty++`]] + [.contract] [[DoubleEndedQueue]] -=== `++DoubleEndedQueue++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/DoubleEndedQueue.sol[{github-icon},role=heading-link] +=== `++DoubleEndedQueue++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/DoubleEndedQueue.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5055,9 +5615,17 @@ Returns true if the queue is empty. :last: pass:normal[xref:#CircularBuffer-last-struct-CircularBuffer-Bytes32CircularBuffer-uint256-[`++last++`]] :includes: pass:normal[xref:#CircularBuffer-includes-struct-CircularBuffer-Bytes32CircularBuffer-bytes32-[`++includes++`]] +:setup-struct-CircularBuffer-Bytes32CircularBuffer-uint256: pass:normal[xref:#CircularBuffer-setup-struct-CircularBuffer-Bytes32CircularBuffer-uint256-[`++setup++`]] +:clear-struct-CircularBuffer-Bytes32CircularBuffer: pass:normal[xref:#CircularBuffer-clear-struct-CircularBuffer-Bytes32CircularBuffer-[`++clear++`]] +:push-struct-CircularBuffer-Bytes32CircularBuffer-bytes32: pass:normal[xref:#CircularBuffer-push-struct-CircularBuffer-Bytes32CircularBuffer-bytes32-[`++push++`]] +:count-struct-CircularBuffer-Bytes32CircularBuffer: pass:normal[xref:#CircularBuffer-count-struct-CircularBuffer-Bytes32CircularBuffer-[`++count++`]] +:length-struct-CircularBuffer-Bytes32CircularBuffer: pass:normal[xref:#CircularBuffer-length-struct-CircularBuffer-Bytes32CircularBuffer-[`++length++`]] +:last-struct-CircularBuffer-Bytes32CircularBuffer-uint256: pass:normal[xref:#CircularBuffer-last-struct-CircularBuffer-Bytes32CircularBuffer-uint256-[`++last++`]] +:includes-struct-CircularBuffer-Bytes32CircularBuffer-bytes32: pass:normal[xref:#CircularBuffer-includes-struct-CircularBuffer-Bytes32CircularBuffer-bytes32-[`++includes++`]] + [.contract] [[CircularBuffer]] -=== `++CircularBuffer++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/CircularBuffer.sol[{github-icon},role=heading-link] +=== `++CircularBuffer++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/CircularBuffer.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5119,7 +5687,7 @@ _Available since v5.1._ [[CircularBuffer-setup-struct-CircularBuffer-Bytes32CircularBuffer-uint256-]] ==== `[.contract-item-name]#++setup++#++(struct CircularBuffer.Bytes32CircularBuffer self, uint256 size)++` [.item-kind]#internal# -Initialize a new CircularBuffer of given size. +Initialize a new CircularBuffer of a given size. If the CircularBuffer was already setup and used, calling that function again will reset it to a blank state. @@ -5205,9 +5773,34 @@ Error emitted when trying to setup a buffer with a size of 0. :length: pass:normal[xref:#Checkpoints-length-struct-Checkpoints-Trace160-[`++length++`]] :at: pass:normal[xref:#Checkpoints-at-struct-Checkpoints-Trace160-uint32-[`++at++`]] +:push-struct-Checkpoints-Trace224-uint32-uint224: pass:normal[xref:#Checkpoints-push-struct-Checkpoints-Trace224-uint32-uint224-[`++push++`]] +:lowerLookup-struct-Checkpoints-Trace224-uint32: pass:normal[xref:#Checkpoints-lowerLookup-struct-Checkpoints-Trace224-uint32-[`++lowerLookup++`]] +:upperLookup-struct-Checkpoints-Trace224-uint32: pass:normal[xref:#Checkpoints-upperLookup-struct-Checkpoints-Trace224-uint32-[`++upperLookup++`]] +:upperLookupRecent-struct-Checkpoints-Trace224-uint32: pass:normal[xref:#Checkpoints-upperLookupRecent-struct-Checkpoints-Trace224-uint32-[`++upperLookupRecent++`]] +:latest-struct-Checkpoints-Trace224: pass:normal[xref:#Checkpoints-latest-struct-Checkpoints-Trace224-[`++latest++`]] +:latestCheckpoint-struct-Checkpoints-Trace224: pass:normal[xref:#Checkpoints-latestCheckpoint-struct-Checkpoints-Trace224-[`++latestCheckpoint++`]] +:length-struct-Checkpoints-Trace224: pass:normal[xref:#Checkpoints-length-struct-Checkpoints-Trace224-[`++length++`]] +:at-struct-Checkpoints-Trace224-uint32: pass:normal[xref:#Checkpoints-at-struct-Checkpoints-Trace224-uint32-[`++at++`]] +:push-struct-Checkpoints-Trace208-uint48-uint208: pass:normal[xref:#Checkpoints-push-struct-Checkpoints-Trace208-uint48-uint208-[`++push++`]] +:lowerLookup-struct-Checkpoints-Trace208-uint48: pass:normal[xref:#Checkpoints-lowerLookup-struct-Checkpoints-Trace208-uint48-[`++lowerLookup++`]] +:upperLookup-struct-Checkpoints-Trace208-uint48: pass:normal[xref:#Checkpoints-upperLookup-struct-Checkpoints-Trace208-uint48-[`++upperLookup++`]] +:upperLookupRecent-struct-Checkpoints-Trace208-uint48: pass:normal[xref:#Checkpoints-upperLookupRecent-struct-Checkpoints-Trace208-uint48-[`++upperLookupRecent++`]] +:latest-struct-Checkpoints-Trace208: pass:normal[xref:#Checkpoints-latest-struct-Checkpoints-Trace208-[`++latest++`]] +:latestCheckpoint-struct-Checkpoints-Trace208: pass:normal[xref:#Checkpoints-latestCheckpoint-struct-Checkpoints-Trace208-[`++latestCheckpoint++`]] +:length-struct-Checkpoints-Trace208: pass:normal[xref:#Checkpoints-length-struct-Checkpoints-Trace208-[`++length++`]] +:at-struct-Checkpoints-Trace208-uint32: pass:normal[xref:#Checkpoints-at-struct-Checkpoints-Trace208-uint32-[`++at++`]] +:push-struct-Checkpoints-Trace160-uint96-uint160: pass:normal[xref:#Checkpoints-push-struct-Checkpoints-Trace160-uint96-uint160-[`++push++`]] +:lowerLookup-struct-Checkpoints-Trace160-uint96: pass:normal[xref:#Checkpoints-lowerLookup-struct-Checkpoints-Trace160-uint96-[`++lowerLookup++`]] +:upperLookup-struct-Checkpoints-Trace160-uint96: pass:normal[xref:#Checkpoints-upperLookup-struct-Checkpoints-Trace160-uint96-[`++upperLookup++`]] +:upperLookupRecent-struct-Checkpoints-Trace160-uint96: pass:normal[xref:#Checkpoints-upperLookupRecent-struct-Checkpoints-Trace160-uint96-[`++upperLookupRecent++`]] +:latest-struct-Checkpoints-Trace160: pass:normal[xref:#Checkpoints-latest-struct-Checkpoints-Trace160-[`++latest++`]] +:latestCheckpoint-struct-Checkpoints-Trace160: pass:normal[xref:#Checkpoints-latestCheckpoint-struct-Checkpoints-Trace160-[`++latestCheckpoint++`]] +:length-struct-Checkpoints-Trace160: pass:normal[xref:#Checkpoints-length-struct-Checkpoints-Trace160-[`++length++`]] +:at-struct-Checkpoints-Trace160-uint32: pass:normal[xref:#Checkpoints-at-struct-Checkpoints-Trace160-uint32-[`++at++`]] + [.contract] [[Checkpoints]] -=== `++Checkpoints++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/Checkpoints.sol[{github-icon},role=heading-link] +=== `++Checkpoints++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/Checkpoints.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5309,7 +5902,7 @@ in the most recent checkpoint. [[Checkpoints-length-struct-Checkpoints-Trace224-]] ==== `[.contract-item-name]#++length++#++(struct Checkpoints.Trace224 self) → uint256++` [.item-kind]#internal# -Returns the number of checkpoint. +Returns the number of checkpoints. [.contract-item] [[Checkpoints-at-struct-Checkpoints-Trace224-uint32-]] @@ -5369,7 +5962,7 @@ in the most recent checkpoint. [[Checkpoints-length-struct-Checkpoints-Trace208-]] ==== `[.contract-item-name]#++length++#++(struct Checkpoints.Trace208 self) → uint256++` [.item-kind]#internal# -Returns the number of checkpoint. +Returns the number of checkpoints. [.contract-item] [[Checkpoints-at-struct-Checkpoints-Trace208-uint32-]] @@ -5429,7 +6022,7 @@ in the most recent checkpoint. [[Checkpoints-length-struct-Checkpoints-Trace160-]] ==== `[.contract-item-name]#++length++#++(struct Checkpoints.Trace160 self) → uint256++` [.item-kind]#internal# -Returns the number of checkpoint. +Returns the number of checkpoints. [.contract-item] [[Checkpoints-at-struct-Checkpoints-Trace160-uint32-]] @@ -5454,9 +6047,19 @@ A value was attempted to be inserted on a past checkpoint. :length: pass:normal[xref:#Heap-length-struct-Heap-Uint256Heap-[`++length++`]] :clear: pass:normal[xref:#Heap-clear-struct-Heap-Uint256Heap-[`++clear++`]] +:peek-struct-Heap-Uint256Heap: pass:normal[xref:#Heap-peek-struct-Heap-Uint256Heap-[`++peek++`]] +:pop-struct-Heap-Uint256Heap: pass:normal[xref:#Heap-pop-struct-Heap-Uint256Heap-[`++pop++`]] +:pop-struct-Heap-Uint256Heap-function--uint256-uint256--view-returns--bool-: pass:normal[xref:#Heap-pop-struct-Heap-Uint256Heap-function--uint256-uint256--view-returns--bool--[`++pop++`]] +:insert-struct-Heap-Uint256Heap-uint256: pass:normal[xref:#Heap-insert-struct-Heap-Uint256Heap-uint256-[`++insert++`]] +:insert-struct-Heap-Uint256Heap-uint256-function--uint256-uint256--view-returns--bool-: pass:normal[xref:#Heap-insert-struct-Heap-Uint256Heap-uint256-function--uint256-uint256--view-returns--bool--[`++insert++`]] +:replace-struct-Heap-Uint256Heap-uint256: pass:normal[xref:#Heap-replace-struct-Heap-Uint256Heap-uint256-[`++replace++`]] +:replace-struct-Heap-Uint256Heap-uint256-function--uint256-uint256--view-returns--bool-: pass:normal[xref:#Heap-replace-struct-Heap-Uint256Heap-uint256-function--uint256-uint256--view-returns--bool--[`++replace++`]] +:length-struct-Heap-Uint256Heap: pass:normal[xref:#Heap-length-struct-Heap-Uint256Heap-[`++length++`]] +:clear-struct-Heap-Uint256Heap: pass:normal[xref:#Heap-clear-struct-Heap-Uint256Heap-[`++clear++`]] + [.contract] [[Heap]] -=== `++Heap++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/Heap.sol[{github-icon},role=heading-link] +=== `++Heap++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/Heap.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5578,16 +6181,28 @@ Returns the number of elements in the heap. Removes all elements in the heap. +:MerkleTreeUpdateInvalidIndex: pass:normal[xref:#MerkleTree-MerkleTreeUpdateInvalidIndex-uint256-uint256-[`++MerkleTreeUpdateInvalidIndex++`]] +:MerkleTreeUpdateInvalidProof: pass:normal[xref:#MerkleTree-MerkleTreeUpdateInvalidProof--[`++MerkleTreeUpdateInvalidProof++`]] :Bytes32PushTree: pass:normal[xref:#MerkleTree-Bytes32PushTree[`++Bytes32PushTree++`]] :setup: pass:normal[xref:#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-[`++setup++`]] :setup: pass:normal[xref:#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++setup++`]] :push: pass:normal[xref:#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-[`++push++`]] :push: pass:normal[xref:#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++push++`]] +:update: pass:normal[xref:#MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---[`++update++`]] +:update: pass:normal[xref:#MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++update++`]] :depth: pass:normal[xref:#MerkleTree-depth-struct-MerkleTree-Bytes32PushTree-[`++depth++`]] +:setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32: pass:normal[xref:#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-[`++setup++`]] +:setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++setup++`]] +:push-struct-MerkleTree-Bytes32PushTree-bytes32: pass:normal[xref:#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-[`++push++`]] +:push-struct-MerkleTree-Bytes32PushTree-bytes32-function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-function--bytes32-bytes32--view-returns--bytes32--[`++push++`]] +:update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32--: pass:normal[xref:#MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---[`++update++`]] +:update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32-: pass:normal[xref:#MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--[`++update++`]] +:depth-struct-MerkleTree-Bytes32PushTree: pass:normal[xref:#MerkleTree-depth-struct-MerkleTree-Bytes32PushTree-[`++depth++`]] + [.contract] [[MerkleTree]] -=== `++MerkleTree++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/structs/MerkleTree.sol[{github-icon},role=heading-link] +=== `++MerkleTree++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/structs/MerkleTree.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5619,10 +6234,20 @@ _Available since v5.1._ * {xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-function--bytes32-bytes32--view-returns--bytes32--}[`++setup(self, treeDepth, zero, fnHash)++`] * {xref-MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-}[`++push(self, leaf)++`] * {xref-MerkleTree-push-struct-MerkleTree-Bytes32PushTree-bytes32-function--bytes32-bytes32--view-returns--bytes32--}[`++push(self, leaf, fnHash)++`] +* {xref-MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---}[`++update(self, index, oldValue, newValue, proof)++`] +* {xref-MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--}[`++update(self, index, oldValue, newValue, proof, fnHash)++`] * {xref-MerkleTree-depth-struct-MerkleTree-Bytes32PushTree-}[`++depth(self)++`] -- +[.contract-index] +.Errors +-- +* {xref-MerkleTree-MerkleTreeUpdateInvalidIndex-uint256-uint256-}[`++MerkleTreeUpdateInvalidIndex(index, length)++`] +* {xref-MerkleTree-MerkleTreeUpdateInvalidProof--}[`++MerkleTreeUpdateInvalidProof()++`] + +-- + [.contract-item] [[MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-]] ==== `[.contract-item-name]#++setup++#++(struct MerkleTree.Bytes32PushTree self, uint8 treeDepth, bytes32 zero) → bytes32 initialRoot++` [.item-kind]#internal# @@ -5680,12 +6305,55 @@ second pre-image attacks. This variant uses a custom hashing function to hash internal nodes. It should only be called with the same function as the one used during the initial setup of the merkle tree. +[.contract-item] +[[MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---]] +==== `[.contract-item-name]#++update++#++(struct MerkleTree.Bytes32PushTree self, uint256 index, bytes32 oldValue, bytes32 newValue, bytes32[] proof) → bytes32 oldRoot, bytes32 newRoot++` [.item-kind]#internal# + +Change the value of the leaf at position `index` from `oldValue` to `newValue`. Returns the recomputed "old" +root (before the update) and "new" root (after the update). The caller must verify that the reconstructed old +root is the last known one. + +The `proof` must be an up-to-date inclusion proof for the leaf being updated. This means that this function is +vulnerable to front-running. Any {push} or {update} operation (that changes the root of the tree) would render +all "in flight" updates invalid. + +This variant uses {Hashes-commutativeKeccak256} to hash internal nodes. It should only be used on merkle trees +that were setup using the same (default) hashing function (i.e. by calling +{xref-MerkleTree-setup-struct-MerkleTree-Bytes32PushTree-uint8-bytes32-}[the default setup] function). + +[.contract-item] +[[MerkleTree-update-struct-MerkleTree-Bytes32PushTree-uint256-bytes32-bytes32-bytes32---function--bytes32-bytes32--view-returns--bytes32--]] +==== `[.contract-item-name]#++update++#++(struct MerkleTree.Bytes32PushTree self, uint256 index, bytes32 oldValue, bytes32 newValue, bytes32[] proof, function (bytes32,bytes32) view returns (bytes32) fnHash) → bytes32 oldRoot, bytes32 newRoot++` [.item-kind]#internal# + +Change the value of the leaf at position `index` from `oldValue` to `newValue`. Returns the recomputed "old" +root (before the update) and "new" root (after the update). The caller must verify that the reconstructed old +root is the last known one. + +The `proof` must be an up-to-date inclusion proof for the leaf being update. This means that this function is +vulnerable to front-running. Any {push} or {update} operation (that changes the root of the tree) would render +all "in flight" updates invalid. + +This variant uses a custom hashing function to hash internal nodes. It should only be called with the same +function as the one used during the initial setup of the merkle tree. + [.contract-item] [[MerkleTree-depth-struct-MerkleTree-Bytes32PushTree-]] ==== `[.contract-item-name]#++depth++#++(struct MerkleTree.Bytes32PushTree self) → uint256++` [.item-kind]#internal# Tree's depth (set at initialization) +[.contract-item] +[[MerkleTree-MerkleTreeUpdateInvalidIndex-uint256-uint256-]] +==== `[.contract-item-name]#++MerkleTreeUpdateInvalidIndex++#++(uint256 index, uint256 length)++` [.item-kind]#error# + +Error emitted when trying to update a leaf that was not previously pushed. + +[.contract-item] +[[MerkleTree-MerkleTreeUpdateInvalidProof--]] +==== `[.contract-item-name]#++MerkleTreeUpdateInvalidProof++#++()++` [.item-kind]#error# + +Error emitted when the proof used during an update is invalid (could not reproduce the side). + == Libraries :Create2EmptyBytecode: pass:normal[xref:#Create2-Create2EmptyBytecode--[`++Create2EmptyBytecode++`]] @@ -5693,9 +6361,13 @@ Tree's depth (set at initialization) :computeAddress: pass:normal[xref:#Create2-computeAddress-bytes32-bytes32-[`++computeAddress++`]] :computeAddress: pass:normal[xref:#Create2-computeAddress-bytes32-bytes32-address-[`++computeAddress++`]] +:deploy-uint256-bytes32-bytes: pass:normal[xref:#Create2-deploy-uint256-bytes32-bytes-[`++deploy++`]] +:computeAddress-bytes32-bytes32: pass:normal[xref:#Create2-computeAddress-bytes32-bytes32-[`++computeAddress++`]] +:computeAddress-bytes32-bytes32-address: pass:normal[xref:#Create2-computeAddress-bytes32-bytes32-address-[`++computeAddress++`]] + [.contract] [[Create2]] -=== `++Create2++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Create2.sol[{github-icon},role=heading-link] +=== `++Create2++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Create2.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5772,9 +6444,17 @@ There's no code to deploy. :verifyCallResultFromTarget: pass:normal[xref:#Address-verifyCallResultFromTarget-address-bool-bytes-[`++verifyCallResultFromTarget++`]] :verifyCallResult: pass:normal[xref:#Address-verifyCallResult-bool-bytes-[`++verifyCallResult++`]] +:sendValue-address-payable-uint256: pass:normal[xref:#Address-sendValue-address-payable-uint256-[`++sendValue++`]] +:functionCall-address-bytes: pass:normal[xref:#Address-functionCall-address-bytes-[`++functionCall++`]] +:functionCallWithValue-address-bytes-uint256: pass:normal[xref:#Address-functionCallWithValue-address-bytes-uint256-[`++functionCallWithValue++`]] +:functionStaticCall-address-bytes: pass:normal[xref:#Address-functionStaticCall-address-bytes-[`++functionStaticCall++`]] +:functionDelegateCall-address-bytes: pass:normal[xref:#Address-functionDelegateCall-address-bytes-[`++functionDelegateCall++`]] +:verifyCallResultFromTarget-address-bool-bytes: pass:normal[xref:#Address-verifyCallResultFromTarget-address-bool-bytes-[`++verifyCallResultFromTarget++`]] +:verifyCallResult-bool-bytes: pass:normal[xref:#Address-verifyCallResult-bool-bytes-[`++verifyCallResult++`]] + [.contract] [[Address]] -=== `++Address++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Address.sol[{github-icon},role=heading-link] +=== `++Address++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Address.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -5911,9 +6591,30 @@ There's no code at `target` (it is not a contract). :unsafeSetLength: pass:normal[xref:#Arrays-unsafeSetLength-bytes32---uint256-[`++unsafeSetLength++`]] :unsafeSetLength: pass:normal[xref:#Arrays-unsafeSetLength-uint256---uint256-[`++unsafeSetLength++`]] +:sort-uint256---function--uint256-uint256--pure-returns--bool-: pass:normal[xref:#Arrays-sort-uint256---function--uint256-uint256--pure-returns--bool--[`++sort++`]] +:sort-uint256--: pass:normal[xref:#Arrays-sort-uint256---[`++sort++`]] +:sort-address---function--address-address--pure-returns--bool-: pass:normal[xref:#Arrays-sort-address---function--address-address--pure-returns--bool--[`++sort++`]] +:sort-address--: pass:normal[xref:#Arrays-sort-address---[`++sort++`]] +:sort-bytes32---function--bytes32-bytes32--pure-returns--bool-: pass:normal[xref:#Arrays-sort-bytes32---function--bytes32-bytes32--pure-returns--bool--[`++sort++`]] +:sort-bytes32--: pass:normal[xref:#Arrays-sort-bytes32---[`++sort++`]] +:findUpperBound-uint256---uint256: pass:normal[xref:#Arrays-findUpperBound-uint256---uint256-[`++findUpperBound++`]] +:lowerBound-uint256---uint256: pass:normal[xref:#Arrays-lowerBound-uint256---uint256-[`++lowerBound++`]] +:upperBound-uint256---uint256: pass:normal[xref:#Arrays-upperBound-uint256---uint256-[`++upperBound++`]] +:lowerBoundMemory-uint256---uint256: pass:normal[xref:#Arrays-lowerBoundMemory-uint256---uint256-[`++lowerBoundMemory++`]] +:upperBoundMemory-uint256---uint256: pass:normal[xref:#Arrays-upperBoundMemory-uint256---uint256-[`++upperBoundMemory++`]] +:unsafeAccess-address---uint256: pass:normal[xref:#Arrays-unsafeAccess-address---uint256-[`++unsafeAccess++`]] +:unsafeAccess-bytes32---uint256: pass:normal[xref:#Arrays-unsafeAccess-bytes32---uint256-[`++unsafeAccess++`]] +:unsafeAccess-uint256---uint256: pass:normal[xref:#Arrays-unsafeAccess-uint256---uint256-[`++unsafeAccess++`]] +:unsafeMemoryAccess-address---uint256: pass:normal[xref:#Arrays-unsafeMemoryAccess-address---uint256-[`++unsafeMemoryAccess++`]] +:unsafeMemoryAccess-bytes32---uint256: pass:normal[xref:#Arrays-unsafeMemoryAccess-bytes32---uint256-[`++unsafeMemoryAccess++`]] +:unsafeMemoryAccess-uint256---uint256: pass:normal[xref:#Arrays-unsafeMemoryAccess-uint256---uint256-[`++unsafeMemoryAccess++`]] +:unsafeSetLength-address---uint256: pass:normal[xref:#Arrays-unsafeSetLength-address---uint256-[`++unsafeSetLength++`]] +:unsafeSetLength-bytes32---uint256: pass:normal[xref:#Arrays-unsafeSetLength-bytes32---uint256-[`++unsafeSetLength++`]] +:unsafeSetLength-uint256---uint256: pass:normal[xref:#Arrays-unsafeSetLength-uint256---uint256-[`++unsafeSetLength++`]] + [.contract] [[Arrays]] -=== `++Arrays++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Arrays.sol[{github-icon},role=heading-link] +=== `++Arrays++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Arrays.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6116,7 +6817,7 @@ WARNING: Only use if you are certain `pos` is lower than the array length. [[Arrays-unsafeSetLength-address---uint256-]] ==== `[.contract-item-name]#++unsafeSetLength++#++(address[] array, uint256 len)++` [.item-kind]#internal# -Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. +Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden. WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. @@ -6124,7 +6825,7 @@ WARNING: this does not clear elements if length is reduced, of initialize elemen [[Arrays-unsafeSetLength-bytes32---uint256-]] ==== `[.contract-item-name]#++unsafeSetLength++#++(bytes32[] array, uint256 len)++` [.item-kind]#internal# -Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. +Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden. WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. @@ -6132,7 +6833,7 @@ WARNING: this does not clear elements if length is reduced, of initialize elemen [[Arrays-unsafeSetLength-uint256---uint256-]] ==== `[.contract-item-name]#++unsafeSetLength++#++(uint256[] array, uint256 len)++` [.item-kind]#internal# -Helper to set the length of an dynamic array. Directly writing to `.length` is forbidden. +Helper to set the length of a dynamic array. Directly writing to `.length` is forbidden. WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. @@ -6141,9 +6842,12 @@ WARNING: this does not clear elements if length is reduced, of initialize elemen :encode: pass:normal[xref:#Base64-encode-bytes-[`++encode++`]] :encodeURL: pass:normal[xref:#Base64-encodeURL-bytes-[`++encodeURL++`]] +:encode-bytes: pass:normal[xref:#Base64-encode-bytes-[`++encode++`]] +:encodeURL-bytes: pass:normal[xref:#Base64-encodeURL-bytes-[`++encodeURL++`]] + [.contract] [[Base64]] -=== `++Base64++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Base64.sol[{github-icon},role=heading-link] +=== `++Base64++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Base64.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6192,6 +6896,134 @@ See sections 4 and 5 of https://datatracker.ietf.org/doc/html/rfc4648 [[Base64-_TABLE_URL-string]] ==== `string [.contract-item-name]#++_TABLE_URL++#` [.item-kind]#internal constant# +:indexOf: pass:normal[xref:#Bytes-indexOf-bytes-bytes1-[`++indexOf++`]] +:indexOf: pass:normal[xref:#Bytes-indexOf-bytes-bytes1-uint256-[`++indexOf++`]] +:lastIndexOf: pass:normal[xref:#Bytes-lastIndexOf-bytes-bytes1-[`++lastIndexOf++`]] +:lastIndexOf: pass:normal[xref:#Bytes-lastIndexOf-bytes-bytes1-uint256-[`++lastIndexOf++`]] +:slice: pass:normal[xref:#Bytes-slice-bytes-uint256-[`++slice++`]] +:slice: pass:normal[xref:#Bytes-slice-bytes-uint256-uint256-[`++slice++`]] + +:indexOf-bytes-bytes1: pass:normal[xref:#Bytes-indexOf-bytes-bytes1-[`++indexOf++`]] +:indexOf-bytes-bytes1-uint256: pass:normal[xref:#Bytes-indexOf-bytes-bytes1-uint256-[`++indexOf++`]] +:lastIndexOf-bytes-bytes1: pass:normal[xref:#Bytes-lastIndexOf-bytes-bytes1-[`++lastIndexOf++`]] +:lastIndexOf-bytes-bytes1-uint256: pass:normal[xref:#Bytes-lastIndexOf-bytes-bytes1-uint256-[`++lastIndexOf++`]] +:slice-bytes-uint256: pass:normal[xref:#Bytes-slice-bytes-uint256-[`++slice++`]] +:slice-bytes-uint256-uint256: pass:normal[xref:#Bytes-slice-bytes-uint256-uint256-[`++slice++`]] + +[.contract] +[[Bytes]] +=== `++Bytes++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Bytes.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/utils/Bytes.sol"; +``` + +Bytes operations. + +[.contract-index] +.Functions +-- +* {xref-Bytes-indexOf-bytes-bytes1-}[`++indexOf(buffer, s)++`] +* {xref-Bytes-indexOf-bytes-bytes1-uint256-}[`++indexOf(buffer, s, pos)++`] +* {xref-Bytes-lastIndexOf-bytes-bytes1-}[`++lastIndexOf(buffer, s)++`] +* {xref-Bytes-lastIndexOf-bytes-bytes1-uint256-}[`++lastIndexOf(buffer, s, pos)++`] +* {xref-Bytes-slice-bytes-uint256-}[`++slice(buffer, start)++`] +* {xref-Bytes-slice-bytes-uint256-uint256-}[`++slice(buffer, start, end)++`] + +-- + +[.contract-item] +[[Bytes-indexOf-bytes-bytes1-]] +==== `[.contract-item-name]#++indexOf++#++(bytes buffer, bytes1 s) → uint256++` [.item-kind]#internal# + +Forward search for `s` in `buffer` +* If `s` is present in the buffer, returns the index of the first instance +* If `s` is not present in the buffer, returns type(uint256).max + +NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`] + +[.contract-item] +[[Bytes-indexOf-bytes-bytes1-uint256-]] +==== `[.contract-item-name]#++indexOf++#++(bytes buffer, bytes1 s, uint256 pos) → uint256++` [.item-kind]#internal# + +Forward search for `s` in `buffer` starting at position `pos` +* If `s` is present in the buffer (at or after `pos`), returns the index of the next instance +* If `s` is not present in the buffer (at or after `pos`), returns type(uint256).max + +NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf[Javascript's `Array.indexOf`] + +[.contract-item] +[[Bytes-lastIndexOf-bytes-bytes1-]] +==== `[.contract-item-name]#++lastIndexOf++#++(bytes buffer, bytes1 s) → uint256++` [.item-kind]#internal# + +Backward search for `s` in `buffer` +* If `s` is present in the buffer, returns the index of the last instance +* If `s` is not present in the buffer, returns type(uint256).max + +NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`] + +[.contract-item] +[[Bytes-lastIndexOf-bytes-bytes1-uint256-]] +==== `[.contract-item-name]#++lastIndexOf++#++(bytes buffer, bytes1 s, uint256 pos) → uint256++` [.item-kind]#internal# + +Backward search for `s` in `buffer` starting at position `pos` +* If `s` is present in the buffer (at or before `pos`), returns the index of the previous instance +* If `s` is not present in the buffer (at or before `pos`), returns type(uint256).max + +NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf[Javascript's `Array.lastIndexOf`] + +[.contract-item] +[[Bytes-slice-bytes-uint256-]] +==== `[.contract-item-name]#++slice++#++(bytes buffer, uint256 start) → bytes++` [.item-kind]#internal# + +Copies the content of `buffer`, from `start` (included) to the end of `buffer` into a new bytes object in +memory. + +NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`] + +[.contract-item] +[[Bytes-slice-bytes-uint256-uint256-]] +==== `[.contract-item-name]#++slice++#++(bytes buffer, uint256 start, uint256 end) → bytes++` [.item-kind]#internal# + +Copies the content of `buffer`, from `start` (included) to `end` (excluded) into a new bytes object in +memory. + +NOTE: replicates the behavior of https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice[Javascript's `Array.slice`] + +:emptyBytes: pass:normal[xref:#Calldata-emptyBytes--[`++emptyBytes++`]] +:emptyString: pass:normal[xref:#Calldata-emptyString--[`++emptyString++`]] + +:emptyBytes-: pass:normal[xref:#Calldata-emptyBytes--[`++emptyBytes++`]] +:emptyString-: pass:normal[xref:#Calldata-emptyString--[`++emptyString++`]] + +[.contract] +[[Calldata]] +=== `++Calldata++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Calldata.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/utils/Calldata.sol"; +``` + +Helper library for manipulating objects in calldata. + +[.contract-index] +.Functions +-- +* {xref-Calldata-emptyBytes--}[`++emptyBytes()++`] +* {xref-Calldata-emptyString--}[`++emptyString()++`] + +-- + +[.contract-item] +[[Calldata-emptyBytes--]] +==== `[.contract-item-name]#++emptyBytes++#++() → bytes result++` [.item-kind]#internal# + +[.contract-item] +[[Calldata-emptyString--]] +==== `[.contract-item-name]#++emptyString++#++() → string result++` [.item-kind]#internal# + :StringsInsufficientHexLength: pass:normal[xref:#Strings-StringsInsufficientHexLength-uint256-uint256-[`++StringsInsufficientHexLength++`]] :StringsInvalidChar: pass:normal[xref:#Strings-StringsInvalidChar--[`++StringsInvalidChar++`]] :StringsInvalidAddressFormat: pass:normal[xref:#Strings-StringsInvalidAddressFormat--[`++StringsInvalidAddressFormat++`]] @@ -6218,10 +7050,36 @@ See sections 4 and 5 of https://datatracker.ietf.org/doc/html/rfc4648 :parseAddress: pass:normal[xref:#Strings-parseAddress-string-uint256-uint256-[`++parseAddress++`]] :tryParseAddress: pass:normal[xref:#Strings-tryParseAddress-string-[`++tryParseAddress++`]] :tryParseAddress: pass:normal[xref:#Strings-tryParseAddress-string-uint256-uint256-[`++tryParseAddress++`]] +:escapeJSON: pass:normal[xref:#Strings-escapeJSON-string-[`++escapeJSON++`]] + +:toString-uint256: pass:normal[xref:#Strings-toString-uint256-[`++toString++`]] +:toStringSigned-int256: pass:normal[xref:#Strings-toStringSigned-int256-[`++toStringSigned++`]] +:toHexString-uint256: pass:normal[xref:#Strings-toHexString-uint256-[`++toHexString++`]] +:toHexString-uint256-uint256: pass:normal[xref:#Strings-toHexString-uint256-uint256-[`++toHexString++`]] +:toHexString-address: pass:normal[xref:#Strings-toHexString-address-[`++toHexString++`]] +:toChecksumHexString-address: pass:normal[xref:#Strings-toChecksumHexString-address-[`++toChecksumHexString++`]] +:equal-string-string: pass:normal[xref:#Strings-equal-string-string-[`++equal++`]] +:parseUint-string: pass:normal[xref:#Strings-parseUint-string-[`++parseUint++`]] +:parseUint-string-uint256-uint256: pass:normal[xref:#Strings-parseUint-string-uint256-uint256-[`++parseUint++`]] +:tryParseUint-string: pass:normal[xref:#Strings-tryParseUint-string-[`++tryParseUint++`]] +:tryParseUint-string-uint256-uint256: pass:normal[xref:#Strings-tryParseUint-string-uint256-uint256-[`++tryParseUint++`]] +:parseInt-string: pass:normal[xref:#Strings-parseInt-string-[`++parseInt++`]] +:parseInt-string-uint256-uint256: pass:normal[xref:#Strings-parseInt-string-uint256-uint256-[`++parseInt++`]] +:tryParseInt-string: pass:normal[xref:#Strings-tryParseInt-string-[`++tryParseInt++`]] +:tryParseInt-string-uint256-uint256: pass:normal[xref:#Strings-tryParseInt-string-uint256-uint256-[`++tryParseInt++`]] +:parseHexUint-string: pass:normal[xref:#Strings-parseHexUint-string-[`++parseHexUint++`]] +:parseHexUint-string-uint256-uint256: pass:normal[xref:#Strings-parseHexUint-string-uint256-uint256-[`++parseHexUint++`]] +:tryParseHexUint-string: pass:normal[xref:#Strings-tryParseHexUint-string-[`++tryParseHexUint++`]] +:tryParseHexUint-string-uint256-uint256: pass:normal[xref:#Strings-tryParseHexUint-string-uint256-uint256-[`++tryParseHexUint++`]] +:parseAddress-string: pass:normal[xref:#Strings-parseAddress-string-[`++parseAddress++`]] +:parseAddress-string-uint256-uint256: pass:normal[xref:#Strings-parseAddress-string-uint256-uint256-[`++parseAddress++`]] +:tryParseAddress-string: pass:normal[xref:#Strings-tryParseAddress-string-[`++tryParseAddress++`]] +:tryParseAddress-string-uint256-uint256: pass:normal[xref:#Strings-tryParseAddress-string-uint256-uint256-[`++tryParseAddress++`]] +:escapeJSON-string: pass:normal[xref:#Strings-escapeJSON-string-[`++escapeJSON++`]] [.contract] [[Strings]] -=== `++Strings++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Strings.sol[{github-icon},role=heading-link] +=== `++Strings++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Strings.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6256,6 +7114,7 @@ String operations. * {xref-Strings-parseAddress-string-uint256-uint256-}[`++parseAddress(input, begin, end)++`] * {xref-Strings-tryParseAddress-string-}[`++tryParseAddress(input)++`] * {xref-Strings-tryParseAddress-string-uint256-uint256-}[`++tryParseAddress(input, begin, end)++`] +* {xref-Strings-escapeJSON-string-}[`++escapeJSON(input)++`] -- @@ -6326,7 +7185,7 @@ Requirements: [[Strings-parseUint-string-uint256-uint256-]] ==== `[.contract-item-name]#++parseUint++#++(string input, uint256 begin, uint256 end) → uint256++` [.item-kind]#internal# -Variant of {parseUint} that parses a substring of `input` located between position `begin` (included) and +Variant of {parseUint-string} that parses a substring of `input` located between position `begin` (included) and `end` (excluded). Requirements: @@ -6403,7 +7262,7 @@ Requirements: [[Strings-parseHexUint-string-uint256-uint256-]] ==== `[.contract-item-name]#++parseHexUint++#++(string input, uint256 begin, uint256 end) → uint256++` [.item-kind]#internal# -Variant of {parseHexUint} that parses a substring of `input` located between position `begin` (included) and +Variant of {parseHexUint-string} that parses a substring of `input` located between position `begin` (included) and `end` (excluded). Requirements: @@ -6440,7 +7299,7 @@ Requirements: [[Strings-parseAddress-string-uint256-uint256-]] ==== `[.contract-item-name]#++parseAddress++#++(string input, uint256 begin, uint256 end) → address++` [.item-kind]#internal# -Variant of {parseAddress} that parses a substring of `input` located between position `begin` (included) and +Variant of {parseAddress-string} that parses a substring of `input` located between position `begin` (included) and `end` (excluded). Requirements: @@ -6451,14 +7310,26 @@ Requirements: ==== `[.contract-item-name]#++tryParseAddress++#++(string input) → bool success, address value++` [.item-kind]#internal# Variant of {parseAddress-string} that returns false if the parsing fails because the input is not a properly -formatted address. See {parseAddress} requirements. +formatted address. See {parseAddress-string} requirements. [.contract-item] [[Strings-tryParseAddress-string-uint256-uint256-]] ==== `[.contract-item-name]#++tryParseAddress++#++(string input, uint256 begin, uint256 end) → bool success, address value++` [.item-kind]#internal# Variant of {parseAddress-string-uint256-uint256} that returns false if the parsing fails because input is not a properly -formatted address. See {parseAddress} requirements. +formatted address. See {parseAddress-string-uint256-uint256} requirements. + +[.contract-item] +[[Strings-escapeJSON-string-]] +==== `[.contract-item-name]#++escapeJSON++#++(string input) → string++` [.item-kind]#internal# + +Escape special characters in JSON strings. This can be useful to prevent JSON injection in NFT metadata. + +WARNING: This function should only be used in double quoted JSON strings. Single quotes are not escaped. + +NOTE: This function escapes all unicode characters, and not just the ones in ranges defined in section 2.5 of +RFC-4627 (U+0000 to U+001F, U+0022 and U+005C). ECMAScript's `JSON.parse` does recover escaped unicode +characters that are not in this range, but other tooling may provide different results. [.contract-item] [[Strings-StringsInsufficientHexLength-uint256-uint256-]] @@ -6487,9 +7358,16 @@ The string being parsed is not a properly formatted address. :toStringWithFallback: pass:normal[xref:#ShortStrings-toStringWithFallback-ShortString-string-[`++toStringWithFallback++`]] :byteLengthWithFallback: pass:normal[xref:#ShortStrings-byteLengthWithFallback-ShortString-string-[`++byteLengthWithFallback++`]] +:toShortString-string: pass:normal[xref:#ShortStrings-toShortString-string-[`++toShortString++`]] +:toString-ShortString: pass:normal[xref:#ShortStrings-toString-ShortString-[`++toString++`]] +:byteLength-ShortString: pass:normal[xref:#ShortStrings-byteLength-ShortString-[`++byteLength++`]] +:toShortStringWithFallback-string-string: pass:normal[xref:#ShortStrings-toShortStringWithFallback-string-string-[`++toShortStringWithFallback++`]] +:toStringWithFallback-ShortString-string: pass:normal[xref:#ShortStrings-toStringWithFallback-ShortString-string-[`++toStringWithFallback++`]] +:byteLengthWithFallback-ShortString-string: pass:normal[xref:#ShortStrings-byteLengthWithFallback-ShortString-string-[`++byteLengthWithFallback++`]] + [.contract] [[ShortStrings]] -=== `++ShortStrings++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/ShortStrings.sol[{github-icon},role=heading-link] +=== `++ShortStrings++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/ShortStrings.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6573,14 +7451,14 @@ Encode a string into a `ShortString`, or write it to storage if it is too long. [[ShortStrings-toStringWithFallback-ShortString-string-]] ==== `[.contract-item-name]#++toStringWithFallback++#++(ShortString value, string store) → string++` [.item-kind]#internal# -Decode a string that was encoded to `ShortString` or written to storage using {setWithFallback}. +Decode a string that was encoded to `ShortString` or written to storage using {toShortStringWithFallback}. [.contract-item] [[ShortStrings-byteLengthWithFallback-ShortString-string-]] ==== `[.contract-item-name]#++byteLengthWithFallback++#++(ShortString value, string store) → uint256++` [.item-kind]#internal# Return the length of a string that was encoded to `ShortString` or written to storage using -{setWithFallback}. +{toShortStringWithFallback}. WARNING: This will return the "byte length" of the string. This may not reflect the actual length in terms of actual characters as the UTF-8 encoding of a single character can span over multiple bytes. @@ -6604,9 +7482,20 @@ actual characters as the UTF-8 encoding of a single character can span over mult :deriveMapping: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-string-[`++deriveMapping++`]] :deriveMapping: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-bytes-[`++deriveMapping++`]] +:erc7201Slot-string: pass:normal[xref:#SlotDerivation-erc7201Slot-string-[`++erc7201Slot++`]] +:offset-bytes32-uint256: pass:normal[xref:#SlotDerivation-offset-bytes32-uint256-[`++offset++`]] +:deriveArray-bytes32: pass:normal[xref:#SlotDerivation-deriveArray-bytes32-[`++deriveArray++`]] +:deriveMapping-bytes32-address: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-address-[`++deriveMapping++`]] +:deriveMapping-bytes32-bool: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-bool-[`++deriveMapping++`]] +:deriveMapping-bytes32-bytes32: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-bytes32-[`++deriveMapping++`]] +:deriveMapping-bytes32-uint256: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-uint256-[`++deriveMapping++`]] +:deriveMapping-bytes32-int256: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-int256-[`++deriveMapping++`]] +:deriveMapping-bytes32-string: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-string-[`++deriveMapping++`]] +:deriveMapping-bytes32-bytes: pass:normal[xref:#SlotDerivation-deriveMapping-bytes32-bytes-[`++deriveMapping++`]] + [.contract] [[SlotDerivation]] -=== `++SlotDerivation++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/SlotDerivation.sol[{github-icon},role=heading-link] +=== `++SlotDerivation++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/SlotDerivation.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6627,7 +7516,7 @@ contract Example { using SlotDerivation for bytes32; // Declare a namespace - string private constant _NAMESPACE = "" // eg. OpenZeppelin.Slot + string private constant _NAMESPACE = ""; // eg. OpenZeppelin.Slot function setValueInNamespace(uint256 key, address newValue) internal { _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue; @@ -6739,9 +7628,19 @@ Derive the location of a mapping element from the key. :getBytesSlot: pass:normal[xref:#StorageSlot-getBytesSlot-bytes32-[`++getBytesSlot++`]] :getBytesSlot: pass:normal[xref:#StorageSlot-getBytesSlot-bytes-[`++getBytesSlot++`]] +:getAddressSlot-bytes32: pass:normal[xref:#StorageSlot-getAddressSlot-bytes32-[`++getAddressSlot++`]] +:getBooleanSlot-bytes32: pass:normal[xref:#StorageSlot-getBooleanSlot-bytes32-[`++getBooleanSlot++`]] +:getBytes32Slot-bytes32: pass:normal[xref:#StorageSlot-getBytes32Slot-bytes32-[`++getBytes32Slot++`]] +:getUint256Slot-bytes32: pass:normal[xref:#StorageSlot-getUint256Slot-bytes32-[`++getUint256Slot++`]] +:getInt256Slot-bytes32: pass:normal[xref:#StorageSlot-getInt256Slot-bytes32-[`++getInt256Slot++`]] +:getStringSlot-bytes32: pass:normal[xref:#StorageSlot-getStringSlot-bytes32-[`++getStringSlot++`]] +:getStringSlot-string: pass:normal[xref:#StorageSlot-getStringSlot-string-[`++getStringSlot++`]] +:getBytesSlot-bytes32: pass:normal[xref:#StorageSlot-getBytesSlot-bytes32-[`++getBytesSlot++`]] +:getBytesSlot-bytes: pass:normal[xref:#StorageSlot-getBytesSlot-bytes-[`++getBytesSlot++`]] + [.contract] [[StorageSlot]] -=== `++StorageSlot++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/StorageSlot.sol[{github-icon},role=heading-link] +=== `++StorageSlot++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/StorageSlot.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -6864,9 +7763,25 @@ Returns an `BytesSlot` representation of the bytes storage pointer `store`. :tload: pass:normal[xref:#TransientSlot-tload-TransientSlot-Int256Slot-[`++tload++`]] :tstore: pass:normal[xref:#TransientSlot-tstore-TransientSlot-Int256Slot-int256-[`++tstore++`]] +:asAddress-bytes32: pass:normal[xref:#TransientSlot-asAddress-bytes32-[`++asAddress++`]] +:asBoolean-bytes32: pass:normal[xref:#TransientSlot-asBoolean-bytes32-[`++asBoolean++`]] +:asBytes32-bytes32: pass:normal[xref:#TransientSlot-asBytes32-bytes32-[`++asBytes32++`]] +:asUint256-bytes32: pass:normal[xref:#TransientSlot-asUint256-bytes32-[`++asUint256++`]] +:asInt256-bytes32: pass:normal[xref:#TransientSlot-asInt256-bytes32-[`++asInt256++`]] +:tload-TransientSlot-AddressSlot: pass:normal[xref:#TransientSlot-tload-TransientSlot-AddressSlot-[`++tload++`]] +:tstore-TransientSlot-AddressSlot-address: pass:normal[xref:#TransientSlot-tstore-TransientSlot-AddressSlot-address-[`++tstore++`]] +:tload-TransientSlot-BooleanSlot: pass:normal[xref:#TransientSlot-tload-TransientSlot-BooleanSlot-[`++tload++`]] +:tstore-TransientSlot-BooleanSlot-bool: pass:normal[xref:#TransientSlot-tstore-TransientSlot-BooleanSlot-bool-[`++tstore++`]] +:tload-TransientSlot-Bytes32Slot: pass:normal[xref:#TransientSlot-tload-TransientSlot-Bytes32Slot-[`++tload++`]] +:tstore-TransientSlot-Bytes32Slot-bytes32: pass:normal[xref:#TransientSlot-tstore-TransientSlot-Bytes32Slot-bytes32-[`++tstore++`]] +:tload-TransientSlot-Uint256Slot: pass:normal[xref:#TransientSlot-tload-TransientSlot-Uint256Slot-[`++tload++`]] +:tstore-TransientSlot-Uint256Slot-uint256: pass:normal[xref:#TransientSlot-tstore-TransientSlot-Uint256Slot-uint256-[`++tstore++`]] +:tload-TransientSlot-Int256Slot: pass:normal[xref:#TransientSlot-tload-TransientSlot-Int256Slot-[`++tload++`]] +:tstore-TransientSlot-Int256Slot-int256: pass:normal[xref:#TransientSlot-tstore-TransientSlot-Int256Slot-int256-[`++tstore++`]] + [.contract] [[TransientSlot]] -=== `++TransientSlot++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/TransientSlot.sol[{github-icon},role=heading-link] +=== `++TransientSlot++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/TransientSlot.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -7011,9 +7926,11 @@ Store `value` at location `slot` in transient storage. :multicall: pass:normal[xref:#Multicall-multicall-bytes---[`++multicall++`]] +:multicall-bytes--: pass:normal[xref:#Multicall-multicall-bytes---[`++multicall++`]] + [.contract] [[Multicall]] -=== `++Multicall++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Multicall.sol[{github-icon},role=heading-link] +=== `++Multicall++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Multicall.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -7026,10 +7943,10 @@ Consider any assumption about calldata validation performed by the sender may be careful about sending transactions invoking {multicall}. For example, a relay address that filters function selectors won't filter calls nested within a {multicall} operation. -NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {_msgSender}). +NOTE: Since 5.0.1 and 4.9.4, this contract identifies non-canonical contexts (i.e. `msg.sender` is not {Context-_msgSender}). If a non-canonical context is identified, the following self `delegatecall` appends the last bytes of `msg.data` to the subcall. This makes it safe to use with {ERC2771Context}. Contexts that don't affect the resolution of -{_msgSender} are not propagated to subcalls. +{Context-_msgSender} are not propagated to subcalls. [.contract-index] .Functions @@ -7048,9 +7965,13 @@ Receives and executes a batch of function calls on this contract. :_msgData: pass:normal[xref:#Context-_msgData--[`++_msgData++`]] :_contextSuffixLength: pass:normal[xref:#Context-_contextSuffixLength--[`++_contextSuffixLength++`]] +:_msgSender-: pass:normal[xref:#Context-_msgSender--[`++_msgSender++`]] +:_msgData-: pass:normal[xref:#Context-_msgData--[`++_msgData++`]] +:_contextSuffixLength-: pass:normal[xref:#Context-_contextSuffixLength--[`++_contextSuffixLength++`]] + [.contract] [[Context]] -=== `++Context++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Context.sol[{github-icon},role=heading-link] +=== `++Context++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Context.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -7301,9 +8222,222 @@ This contract is only required for intermediate, library-like contracts. :extract_32_28: pass:normal[xref:#Packing-extract_32_28-bytes32-uint8-[`++extract_32_28++`]] :replace_32_28: pass:normal[xref:#Packing-replace_32_28-bytes32-bytes28-uint8-[`++replace_32_28++`]] +:pack_1_1-bytes1-bytes1: pass:normal[xref:#Packing-pack_1_1-bytes1-bytes1-[`++pack_1_1++`]] +:pack_2_2-bytes2-bytes2: pass:normal[xref:#Packing-pack_2_2-bytes2-bytes2-[`++pack_2_2++`]] +:pack_2_4-bytes2-bytes4: pass:normal[xref:#Packing-pack_2_4-bytes2-bytes4-[`++pack_2_4++`]] +:pack_2_6-bytes2-bytes6: pass:normal[xref:#Packing-pack_2_6-bytes2-bytes6-[`++pack_2_6++`]] +:pack_2_8-bytes2-bytes8: pass:normal[xref:#Packing-pack_2_8-bytes2-bytes8-[`++pack_2_8++`]] +:pack_2_10-bytes2-bytes10: pass:normal[xref:#Packing-pack_2_10-bytes2-bytes10-[`++pack_2_10++`]] +:pack_2_20-bytes2-bytes20: pass:normal[xref:#Packing-pack_2_20-bytes2-bytes20-[`++pack_2_20++`]] +:pack_2_22-bytes2-bytes22: pass:normal[xref:#Packing-pack_2_22-bytes2-bytes22-[`++pack_2_22++`]] +:pack_4_2-bytes4-bytes2: pass:normal[xref:#Packing-pack_4_2-bytes4-bytes2-[`++pack_4_2++`]] +:pack_4_4-bytes4-bytes4: pass:normal[xref:#Packing-pack_4_4-bytes4-bytes4-[`++pack_4_4++`]] +:pack_4_6-bytes4-bytes6: pass:normal[xref:#Packing-pack_4_6-bytes4-bytes6-[`++pack_4_6++`]] +:pack_4_8-bytes4-bytes8: pass:normal[xref:#Packing-pack_4_8-bytes4-bytes8-[`++pack_4_8++`]] +:pack_4_12-bytes4-bytes12: pass:normal[xref:#Packing-pack_4_12-bytes4-bytes12-[`++pack_4_12++`]] +:pack_4_16-bytes4-bytes16: pass:normal[xref:#Packing-pack_4_16-bytes4-bytes16-[`++pack_4_16++`]] +:pack_4_20-bytes4-bytes20: pass:normal[xref:#Packing-pack_4_20-bytes4-bytes20-[`++pack_4_20++`]] +:pack_4_24-bytes4-bytes24: pass:normal[xref:#Packing-pack_4_24-bytes4-bytes24-[`++pack_4_24++`]] +:pack_4_28-bytes4-bytes28: pass:normal[xref:#Packing-pack_4_28-bytes4-bytes28-[`++pack_4_28++`]] +:pack_6_2-bytes6-bytes2: pass:normal[xref:#Packing-pack_6_2-bytes6-bytes2-[`++pack_6_2++`]] +:pack_6_4-bytes6-bytes4: pass:normal[xref:#Packing-pack_6_4-bytes6-bytes4-[`++pack_6_4++`]] +:pack_6_6-bytes6-bytes6: pass:normal[xref:#Packing-pack_6_6-bytes6-bytes6-[`++pack_6_6++`]] +:pack_6_10-bytes6-bytes10: pass:normal[xref:#Packing-pack_6_10-bytes6-bytes10-[`++pack_6_10++`]] +:pack_6_16-bytes6-bytes16: pass:normal[xref:#Packing-pack_6_16-bytes6-bytes16-[`++pack_6_16++`]] +:pack_6_22-bytes6-bytes22: pass:normal[xref:#Packing-pack_6_22-bytes6-bytes22-[`++pack_6_22++`]] +:pack_8_2-bytes8-bytes2: pass:normal[xref:#Packing-pack_8_2-bytes8-bytes2-[`++pack_8_2++`]] +:pack_8_4-bytes8-bytes4: pass:normal[xref:#Packing-pack_8_4-bytes8-bytes4-[`++pack_8_4++`]] +:pack_8_8-bytes8-bytes8: pass:normal[xref:#Packing-pack_8_8-bytes8-bytes8-[`++pack_8_8++`]] +:pack_8_12-bytes8-bytes12: pass:normal[xref:#Packing-pack_8_12-bytes8-bytes12-[`++pack_8_12++`]] +:pack_8_16-bytes8-bytes16: pass:normal[xref:#Packing-pack_8_16-bytes8-bytes16-[`++pack_8_16++`]] +:pack_8_20-bytes8-bytes20: pass:normal[xref:#Packing-pack_8_20-bytes8-bytes20-[`++pack_8_20++`]] +:pack_8_24-bytes8-bytes24: pass:normal[xref:#Packing-pack_8_24-bytes8-bytes24-[`++pack_8_24++`]] +:pack_10_2-bytes10-bytes2: pass:normal[xref:#Packing-pack_10_2-bytes10-bytes2-[`++pack_10_2++`]] +:pack_10_6-bytes10-bytes6: pass:normal[xref:#Packing-pack_10_6-bytes10-bytes6-[`++pack_10_6++`]] +:pack_10_10-bytes10-bytes10: pass:normal[xref:#Packing-pack_10_10-bytes10-bytes10-[`++pack_10_10++`]] +:pack_10_12-bytes10-bytes12: pass:normal[xref:#Packing-pack_10_12-bytes10-bytes12-[`++pack_10_12++`]] +:pack_10_22-bytes10-bytes22: pass:normal[xref:#Packing-pack_10_22-bytes10-bytes22-[`++pack_10_22++`]] +:pack_12_4-bytes12-bytes4: pass:normal[xref:#Packing-pack_12_4-bytes12-bytes4-[`++pack_12_4++`]] +:pack_12_8-bytes12-bytes8: pass:normal[xref:#Packing-pack_12_8-bytes12-bytes8-[`++pack_12_8++`]] +:pack_12_10-bytes12-bytes10: pass:normal[xref:#Packing-pack_12_10-bytes12-bytes10-[`++pack_12_10++`]] +:pack_12_12-bytes12-bytes12: pass:normal[xref:#Packing-pack_12_12-bytes12-bytes12-[`++pack_12_12++`]] +:pack_12_16-bytes12-bytes16: pass:normal[xref:#Packing-pack_12_16-bytes12-bytes16-[`++pack_12_16++`]] +:pack_12_20-bytes12-bytes20: pass:normal[xref:#Packing-pack_12_20-bytes12-bytes20-[`++pack_12_20++`]] +:pack_16_4-bytes16-bytes4: pass:normal[xref:#Packing-pack_16_4-bytes16-bytes4-[`++pack_16_4++`]] +:pack_16_6-bytes16-bytes6: pass:normal[xref:#Packing-pack_16_6-bytes16-bytes6-[`++pack_16_6++`]] +:pack_16_8-bytes16-bytes8: pass:normal[xref:#Packing-pack_16_8-bytes16-bytes8-[`++pack_16_8++`]] +:pack_16_12-bytes16-bytes12: pass:normal[xref:#Packing-pack_16_12-bytes16-bytes12-[`++pack_16_12++`]] +:pack_16_16-bytes16-bytes16: pass:normal[xref:#Packing-pack_16_16-bytes16-bytes16-[`++pack_16_16++`]] +:pack_20_2-bytes20-bytes2: pass:normal[xref:#Packing-pack_20_2-bytes20-bytes2-[`++pack_20_2++`]] +:pack_20_4-bytes20-bytes4: pass:normal[xref:#Packing-pack_20_4-bytes20-bytes4-[`++pack_20_4++`]] +:pack_20_8-bytes20-bytes8: pass:normal[xref:#Packing-pack_20_8-bytes20-bytes8-[`++pack_20_8++`]] +:pack_20_12-bytes20-bytes12: pass:normal[xref:#Packing-pack_20_12-bytes20-bytes12-[`++pack_20_12++`]] +:pack_22_2-bytes22-bytes2: pass:normal[xref:#Packing-pack_22_2-bytes22-bytes2-[`++pack_22_2++`]] +:pack_22_6-bytes22-bytes6: pass:normal[xref:#Packing-pack_22_6-bytes22-bytes6-[`++pack_22_6++`]] +:pack_22_10-bytes22-bytes10: pass:normal[xref:#Packing-pack_22_10-bytes22-bytes10-[`++pack_22_10++`]] +:pack_24_4-bytes24-bytes4: pass:normal[xref:#Packing-pack_24_4-bytes24-bytes4-[`++pack_24_4++`]] +:pack_24_8-bytes24-bytes8: pass:normal[xref:#Packing-pack_24_8-bytes24-bytes8-[`++pack_24_8++`]] +:pack_28_4-bytes28-bytes4: pass:normal[xref:#Packing-pack_28_4-bytes28-bytes4-[`++pack_28_4++`]] +:extract_2_1-bytes2-uint8: pass:normal[xref:#Packing-extract_2_1-bytes2-uint8-[`++extract_2_1++`]] +:replace_2_1-bytes2-bytes1-uint8: pass:normal[xref:#Packing-replace_2_1-bytes2-bytes1-uint8-[`++replace_2_1++`]] +:extract_4_1-bytes4-uint8: pass:normal[xref:#Packing-extract_4_1-bytes4-uint8-[`++extract_4_1++`]] +:replace_4_1-bytes4-bytes1-uint8: pass:normal[xref:#Packing-replace_4_1-bytes4-bytes1-uint8-[`++replace_4_1++`]] +:extract_4_2-bytes4-uint8: pass:normal[xref:#Packing-extract_4_2-bytes4-uint8-[`++extract_4_2++`]] +:replace_4_2-bytes4-bytes2-uint8: pass:normal[xref:#Packing-replace_4_2-bytes4-bytes2-uint8-[`++replace_4_2++`]] +:extract_6_1-bytes6-uint8: pass:normal[xref:#Packing-extract_6_1-bytes6-uint8-[`++extract_6_1++`]] +:replace_6_1-bytes6-bytes1-uint8: pass:normal[xref:#Packing-replace_6_1-bytes6-bytes1-uint8-[`++replace_6_1++`]] +:extract_6_2-bytes6-uint8: pass:normal[xref:#Packing-extract_6_2-bytes6-uint8-[`++extract_6_2++`]] +:replace_6_2-bytes6-bytes2-uint8: pass:normal[xref:#Packing-replace_6_2-bytes6-bytes2-uint8-[`++replace_6_2++`]] +:extract_6_4-bytes6-uint8: pass:normal[xref:#Packing-extract_6_4-bytes6-uint8-[`++extract_6_4++`]] +:replace_6_4-bytes6-bytes4-uint8: pass:normal[xref:#Packing-replace_6_4-bytes6-bytes4-uint8-[`++replace_6_4++`]] +:extract_8_1-bytes8-uint8: pass:normal[xref:#Packing-extract_8_1-bytes8-uint8-[`++extract_8_1++`]] +:replace_8_1-bytes8-bytes1-uint8: pass:normal[xref:#Packing-replace_8_1-bytes8-bytes1-uint8-[`++replace_8_1++`]] +:extract_8_2-bytes8-uint8: pass:normal[xref:#Packing-extract_8_2-bytes8-uint8-[`++extract_8_2++`]] +:replace_8_2-bytes8-bytes2-uint8: pass:normal[xref:#Packing-replace_8_2-bytes8-bytes2-uint8-[`++replace_8_2++`]] +:extract_8_4-bytes8-uint8: pass:normal[xref:#Packing-extract_8_4-bytes8-uint8-[`++extract_8_4++`]] +:replace_8_4-bytes8-bytes4-uint8: pass:normal[xref:#Packing-replace_8_4-bytes8-bytes4-uint8-[`++replace_8_4++`]] +:extract_8_6-bytes8-uint8: pass:normal[xref:#Packing-extract_8_6-bytes8-uint8-[`++extract_8_6++`]] +:replace_8_6-bytes8-bytes6-uint8: pass:normal[xref:#Packing-replace_8_6-bytes8-bytes6-uint8-[`++replace_8_6++`]] +:extract_10_1-bytes10-uint8: pass:normal[xref:#Packing-extract_10_1-bytes10-uint8-[`++extract_10_1++`]] +:replace_10_1-bytes10-bytes1-uint8: pass:normal[xref:#Packing-replace_10_1-bytes10-bytes1-uint8-[`++replace_10_1++`]] +:extract_10_2-bytes10-uint8: pass:normal[xref:#Packing-extract_10_2-bytes10-uint8-[`++extract_10_2++`]] +:replace_10_2-bytes10-bytes2-uint8: pass:normal[xref:#Packing-replace_10_2-bytes10-bytes2-uint8-[`++replace_10_2++`]] +:extract_10_4-bytes10-uint8: pass:normal[xref:#Packing-extract_10_4-bytes10-uint8-[`++extract_10_4++`]] +:replace_10_4-bytes10-bytes4-uint8: pass:normal[xref:#Packing-replace_10_4-bytes10-bytes4-uint8-[`++replace_10_4++`]] +:extract_10_6-bytes10-uint8: pass:normal[xref:#Packing-extract_10_6-bytes10-uint8-[`++extract_10_6++`]] +:replace_10_6-bytes10-bytes6-uint8: pass:normal[xref:#Packing-replace_10_6-bytes10-bytes6-uint8-[`++replace_10_6++`]] +:extract_10_8-bytes10-uint8: pass:normal[xref:#Packing-extract_10_8-bytes10-uint8-[`++extract_10_8++`]] +:replace_10_8-bytes10-bytes8-uint8: pass:normal[xref:#Packing-replace_10_8-bytes10-bytes8-uint8-[`++replace_10_8++`]] +:extract_12_1-bytes12-uint8: pass:normal[xref:#Packing-extract_12_1-bytes12-uint8-[`++extract_12_1++`]] +:replace_12_1-bytes12-bytes1-uint8: pass:normal[xref:#Packing-replace_12_1-bytes12-bytes1-uint8-[`++replace_12_1++`]] +:extract_12_2-bytes12-uint8: pass:normal[xref:#Packing-extract_12_2-bytes12-uint8-[`++extract_12_2++`]] +:replace_12_2-bytes12-bytes2-uint8: pass:normal[xref:#Packing-replace_12_2-bytes12-bytes2-uint8-[`++replace_12_2++`]] +:extract_12_4-bytes12-uint8: pass:normal[xref:#Packing-extract_12_4-bytes12-uint8-[`++extract_12_4++`]] +:replace_12_4-bytes12-bytes4-uint8: pass:normal[xref:#Packing-replace_12_4-bytes12-bytes4-uint8-[`++replace_12_4++`]] +:extract_12_6-bytes12-uint8: pass:normal[xref:#Packing-extract_12_6-bytes12-uint8-[`++extract_12_6++`]] +:replace_12_6-bytes12-bytes6-uint8: pass:normal[xref:#Packing-replace_12_6-bytes12-bytes6-uint8-[`++replace_12_6++`]] +:extract_12_8-bytes12-uint8: pass:normal[xref:#Packing-extract_12_8-bytes12-uint8-[`++extract_12_8++`]] +:replace_12_8-bytes12-bytes8-uint8: pass:normal[xref:#Packing-replace_12_8-bytes12-bytes8-uint8-[`++replace_12_8++`]] +:extract_12_10-bytes12-uint8: pass:normal[xref:#Packing-extract_12_10-bytes12-uint8-[`++extract_12_10++`]] +:replace_12_10-bytes12-bytes10-uint8: pass:normal[xref:#Packing-replace_12_10-bytes12-bytes10-uint8-[`++replace_12_10++`]] +:extract_16_1-bytes16-uint8: pass:normal[xref:#Packing-extract_16_1-bytes16-uint8-[`++extract_16_1++`]] +:replace_16_1-bytes16-bytes1-uint8: pass:normal[xref:#Packing-replace_16_1-bytes16-bytes1-uint8-[`++replace_16_1++`]] +:extract_16_2-bytes16-uint8: pass:normal[xref:#Packing-extract_16_2-bytes16-uint8-[`++extract_16_2++`]] +:replace_16_2-bytes16-bytes2-uint8: pass:normal[xref:#Packing-replace_16_2-bytes16-bytes2-uint8-[`++replace_16_2++`]] +:extract_16_4-bytes16-uint8: pass:normal[xref:#Packing-extract_16_4-bytes16-uint8-[`++extract_16_4++`]] +:replace_16_4-bytes16-bytes4-uint8: pass:normal[xref:#Packing-replace_16_4-bytes16-bytes4-uint8-[`++replace_16_4++`]] +:extract_16_6-bytes16-uint8: pass:normal[xref:#Packing-extract_16_6-bytes16-uint8-[`++extract_16_6++`]] +:replace_16_6-bytes16-bytes6-uint8: pass:normal[xref:#Packing-replace_16_6-bytes16-bytes6-uint8-[`++replace_16_6++`]] +:extract_16_8-bytes16-uint8: pass:normal[xref:#Packing-extract_16_8-bytes16-uint8-[`++extract_16_8++`]] +:replace_16_8-bytes16-bytes8-uint8: pass:normal[xref:#Packing-replace_16_8-bytes16-bytes8-uint8-[`++replace_16_8++`]] +:extract_16_10-bytes16-uint8: pass:normal[xref:#Packing-extract_16_10-bytes16-uint8-[`++extract_16_10++`]] +:replace_16_10-bytes16-bytes10-uint8: pass:normal[xref:#Packing-replace_16_10-bytes16-bytes10-uint8-[`++replace_16_10++`]] +:extract_16_12-bytes16-uint8: pass:normal[xref:#Packing-extract_16_12-bytes16-uint8-[`++extract_16_12++`]] +:replace_16_12-bytes16-bytes12-uint8: pass:normal[xref:#Packing-replace_16_12-bytes16-bytes12-uint8-[`++replace_16_12++`]] +:extract_20_1-bytes20-uint8: pass:normal[xref:#Packing-extract_20_1-bytes20-uint8-[`++extract_20_1++`]] +:replace_20_1-bytes20-bytes1-uint8: pass:normal[xref:#Packing-replace_20_1-bytes20-bytes1-uint8-[`++replace_20_1++`]] +:extract_20_2-bytes20-uint8: pass:normal[xref:#Packing-extract_20_2-bytes20-uint8-[`++extract_20_2++`]] +:replace_20_2-bytes20-bytes2-uint8: pass:normal[xref:#Packing-replace_20_2-bytes20-bytes2-uint8-[`++replace_20_2++`]] +:extract_20_4-bytes20-uint8: pass:normal[xref:#Packing-extract_20_4-bytes20-uint8-[`++extract_20_4++`]] +:replace_20_4-bytes20-bytes4-uint8: pass:normal[xref:#Packing-replace_20_4-bytes20-bytes4-uint8-[`++replace_20_4++`]] +:extract_20_6-bytes20-uint8: pass:normal[xref:#Packing-extract_20_6-bytes20-uint8-[`++extract_20_6++`]] +:replace_20_6-bytes20-bytes6-uint8: pass:normal[xref:#Packing-replace_20_6-bytes20-bytes6-uint8-[`++replace_20_6++`]] +:extract_20_8-bytes20-uint8: pass:normal[xref:#Packing-extract_20_8-bytes20-uint8-[`++extract_20_8++`]] +:replace_20_8-bytes20-bytes8-uint8: pass:normal[xref:#Packing-replace_20_8-bytes20-bytes8-uint8-[`++replace_20_8++`]] +:extract_20_10-bytes20-uint8: pass:normal[xref:#Packing-extract_20_10-bytes20-uint8-[`++extract_20_10++`]] +:replace_20_10-bytes20-bytes10-uint8: pass:normal[xref:#Packing-replace_20_10-bytes20-bytes10-uint8-[`++replace_20_10++`]] +:extract_20_12-bytes20-uint8: pass:normal[xref:#Packing-extract_20_12-bytes20-uint8-[`++extract_20_12++`]] +:replace_20_12-bytes20-bytes12-uint8: pass:normal[xref:#Packing-replace_20_12-bytes20-bytes12-uint8-[`++replace_20_12++`]] +:extract_20_16-bytes20-uint8: pass:normal[xref:#Packing-extract_20_16-bytes20-uint8-[`++extract_20_16++`]] +:replace_20_16-bytes20-bytes16-uint8: pass:normal[xref:#Packing-replace_20_16-bytes20-bytes16-uint8-[`++replace_20_16++`]] +:extract_22_1-bytes22-uint8: pass:normal[xref:#Packing-extract_22_1-bytes22-uint8-[`++extract_22_1++`]] +:replace_22_1-bytes22-bytes1-uint8: pass:normal[xref:#Packing-replace_22_1-bytes22-bytes1-uint8-[`++replace_22_1++`]] +:extract_22_2-bytes22-uint8: pass:normal[xref:#Packing-extract_22_2-bytes22-uint8-[`++extract_22_2++`]] +:replace_22_2-bytes22-bytes2-uint8: pass:normal[xref:#Packing-replace_22_2-bytes22-bytes2-uint8-[`++replace_22_2++`]] +:extract_22_4-bytes22-uint8: pass:normal[xref:#Packing-extract_22_4-bytes22-uint8-[`++extract_22_4++`]] +:replace_22_4-bytes22-bytes4-uint8: pass:normal[xref:#Packing-replace_22_4-bytes22-bytes4-uint8-[`++replace_22_4++`]] +:extract_22_6-bytes22-uint8: pass:normal[xref:#Packing-extract_22_6-bytes22-uint8-[`++extract_22_6++`]] +:replace_22_6-bytes22-bytes6-uint8: pass:normal[xref:#Packing-replace_22_6-bytes22-bytes6-uint8-[`++replace_22_6++`]] +:extract_22_8-bytes22-uint8: pass:normal[xref:#Packing-extract_22_8-bytes22-uint8-[`++extract_22_8++`]] +:replace_22_8-bytes22-bytes8-uint8: pass:normal[xref:#Packing-replace_22_8-bytes22-bytes8-uint8-[`++replace_22_8++`]] +:extract_22_10-bytes22-uint8: pass:normal[xref:#Packing-extract_22_10-bytes22-uint8-[`++extract_22_10++`]] +:replace_22_10-bytes22-bytes10-uint8: pass:normal[xref:#Packing-replace_22_10-bytes22-bytes10-uint8-[`++replace_22_10++`]] +:extract_22_12-bytes22-uint8: pass:normal[xref:#Packing-extract_22_12-bytes22-uint8-[`++extract_22_12++`]] +:replace_22_12-bytes22-bytes12-uint8: pass:normal[xref:#Packing-replace_22_12-bytes22-bytes12-uint8-[`++replace_22_12++`]] +:extract_22_16-bytes22-uint8: pass:normal[xref:#Packing-extract_22_16-bytes22-uint8-[`++extract_22_16++`]] +:replace_22_16-bytes22-bytes16-uint8: pass:normal[xref:#Packing-replace_22_16-bytes22-bytes16-uint8-[`++replace_22_16++`]] +:extract_22_20-bytes22-uint8: pass:normal[xref:#Packing-extract_22_20-bytes22-uint8-[`++extract_22_20++`]] +:replace_22_20-bytes22-bytes20-uint8: pass:normal[xref:#Packing-replace_22_20-bytes22-bytes20-uint8-[`++replace_22_20++`]] +:extract_24_1-bytes24-uint8: pass:normal[xref:#Packing-extract_24_1-bytes24-uint8-[`++extract_24_1++`]] +:replace_24_1-bytes24-bytes1-uint8: pass:normal[xref:#Packing-replace_24_1-bytes24-bytes1-uint8-[`++replace_24_1++`]] +:extract_24_2-bytes24-uint8: pass:normal[xref:#Packing-extract_24_2-bytes24-uint8-[`++extract_24_2++`]] +:replace_24_2-bytes24-bytes2-uint8: pass:normal[xref:#Packing-replace_24_2-bytes24-bytes2-uint8-[`++replace_24_2++`]] +:extract_24_4-bytes24-uint8: pass:normal[xref:#Packing-extract_24_4-bytes24-uint8-[`++extract_24_4++`]] +:replace_24_4-bytes24-bytes4-uint8: pass:normal[xref:#Packing-replace_24_4-bytes24-bytes4-uint8-[`++replace_24_4++`]] +:extract_24_6-bytes24-uint8: pass:normal[xref:#Packing-extract_24_6-bytes24-uint8-[`++extract_24_6++`]] +:replace_24_6-bytes24-bytes6-uint8: pass:normal[xref:#Packing-replace_24_6-bytes24-bytes6-uint8-[`++replace_24_6++`]] +:extract_24_8-bytes24-uint8: pass:normal[xref:#Packing-extract_24_8-bytes24-uint8-[`++extract_24_8++`]] +:replace_24_8-bytes24-bytes8-uint8: pass:normal[xref:#Packing-replace_24_8-bytes24-bytes8-uint8-[`++replace_24_8++`]] +:extract_24_10-bytes24-uint8: pass:normal[xref:#Packing-extract_24_10-bytes24-uint8-[`++extract_24_10++`]] +:replace_24_10-bytes24-bytes10-uint8: pass:normal[xref:#Packing-replace_24_10-bytes24-bytes10-uint8-[`++replace_24_10++`]] +:extract_24_12-bytes24-uint8: pass:normal[xref:#Packing-extract_24_12-bytes24-uint8-[`++extract_24_12++`]] +:replace_24_12-bytes24-bytes12-uint8: pass:normal[xref:#Packing-replace_24_12-bytes24-bytes12-uint8-[`++replace_24_12++`]] +:extract_24_16-bytes24-uint8: pass:normal[xref:#Packing-extract_24_16-bytes24-uint8-[`++extract_24_16++`]] +:replace_24_16-bytes24-bytes16-uint8: pass:normal[xref:#Packing-replace_24_16-bytes24-bytes16-uint8-[`++replace_24_16++`]] +:extract_24_20-bytes24-uint8: pass:normal[xref:#Packing-extract_24_20-bytes24-uint8-[`++extract_24_20++`]] +:replace_24_20-bytes24-bytes20-uint8: pass:normal[xref:#Packing-replace_24_20-bytes24-bytes20-uint8-[`++replace_24_20++`]] +:extract_24_22-bytes24-uint8: pass:normal[xref:#Packing-extract_24_22-bytes24-uint8-[`++extract_24_22++`]] +:replace_24_22-bytes24-bytes22-uint8: pass:normal[xref:#Packing-replace_24_22-bytes24-bytes22-uint8-[`++replace_24_22++`]] +:extract_28_1-bytes28-uint8: pass:normal[xref:#Packing-extract_28_1-bytes28-uint8-[`++extract_28_1++`]] +:replace_28_1-bytes28-bytes1-uint8: pass:normal[xref:#Packing-replace_28_1-bytes28-bytes1-uint8-[`++replace_28_1++`]] +:extract_28_2-bytes28-uint8: pass:normal[xref:#Packing-extract_28_2-bytes28-uint8-[`++extract_28_2++`]] +:replace_28_2-bytes28-bytes2-uint8: pass:normal[xref:#Packing-replace_28_2-bytes28-bytes2-uint8-[`++replace_28_2++`]] +:extract_28_4-bytes28-uint8: pass:normal[xref:#Packing-extract_28_4-bytes28-uint8-[`++extract_28_4++`]] +:replace_28_4-bytes28-bytes4-uint8: pass:normal[xref:#Packing-replace_28_4-bytes28-bytes4-uint8-[`++replace_28_4++`]] +:extract_28_6-bytes28-uint8: pass:normal[xref:#Packing-extract_28_6-bytes28-uint8-[`++extract_28_6++`]] +:replace_28_6-bytes28-bytes6-uint8: pass:normal[xref:#Packing-replace_28_6-bytes28-bytes6-uint8-[`++replace_28_6++`]] +:extract_28_8-bytes28-uint8: pass:normal[xref:#Packing-extract_28_8-bytes28-uint8-[`++extract_28_8++`]] +:replace_28_8-bytes28-bytes8-uint8: pass:normal[xref:#Packing-replace_28_8-bytes28-bytes8-uint8-[`++replace_28_8++`]] +:extract_28_10-bytes28-uint8: pass:normal[xref:#Packing-extract_28_10-bytes28-uint8-[`++extract_28_10++`]] +:replace_28_10-bytes28-bytes10-uint8: pass:normal[xref:#Packing-replace_28_10-bytes28-bytes10-uint8-[`++replace_28_10++`]] +:extract_28_12-bytes28-uint8: pass:normal[xref:#Packing-extract_28_12-bytes28-uint8-[`++extract_28_12++`]] +:replace_28_12-bytes28-bytes12-uint8: pass:normal[xref:#Packing-replace_28_12-bytes28-bytes12-uint8-[`++replace_28_12++`]] +:extract_28_16-bytes28-uint8: pass:normal[xref:#Packing-extract_28_16-bytes28-uint8-[`++extract_28_16++`]] +:replace_28_16-bytes28-bytes16-uint8: pass:normal[xref:#Packing-replace_28_16-bytes28-bytes16-uint8-[`++replace_28_16++`]] +:extract_28_20-bytes28-uint8: pass:normal[xref:#Packing-extract_28_20-bytes28-uint8-[`++extract_28_20++`]] +:replace_28_20-bytes28-bytes20-uint8: pass:normal[xref:#Packing-replace_28_20-bytes28-bytes20-uint8-[`++replace_28_20++`]] +:extract_28_22-bytes28-uint8: pass:normal[xref:#Packing-extract_28_22-bytes28-uint8-[`++extract_28_22++`]] +:replace_28_22-bytes28-bytes22-uint8: pass:normal[xref:#Packing-replace_28_22-bytes28-bytes22-uint8-[`++replace_28_22++`]] +:extract_28_24-bytes28-uint8: pass:normal[xref:#Packing-extract_28_24-bytes28-uint8-[`++extract_28_24++`]] +:replace_28_24-bytes28-bytes24-uint8: pass:normal[xref:#Packing-replace_28_24-bytes28-bytes24-uint8-[`++replace_28_24++`]] +:extract_32_1-bytes32-uint8: pass:normal[xref:#Packing-extract_32_1-bytes32-uint8-[`++extract_32_1++`]] +:replace_32_1-bytes32-bytes1-uint8: pass:normal[xref:#Packing-replace_32_1-bytes32-bytes1-uint8-[`++replace_32_1++`]] +:extract_32_2-bytes32-uint8: pass:normal[xref:#Packing-extract_32_2-bytes32-uint8-[`++extract_32_2++`]] +:replace_32_2-bytes32-bytes2-uint8: pass:normal[xref:#Packing-replace_32_2-bytes32-bytes2-uint8-[`++replace_32_2++`]] +:extract_32_4-bytes32-uint8: pass:normal[xref:#Packing-extract_32_4-bytes32-uint8-[`++extract_32_4++`]] +:replace_32_4-bytes32-bytes4-uint8: pass:normal[xref:#Packing-replace_32_4-bytes32-bytes4-uint8-[`++replace_32_4++`]] +:extract_32_6-bytes32-uint8: pass:normal[xref:#Packing-extract_32_6-bytes32-uint8-[`++extract_32_6++`]] +:replace_32_6-bytes32-bytes6-uint8: pass:normal[xref:#Packing-replace_32_6-bytes32-bytes6-uint8-[`++replace_32_6++`]] +:extract_32_8-bytes32-uint8: pass:normal[xref:#Packing-extract_32_8-bytes32-uint8-[`++extract_32_8++`]] +:replace_32_8-bytes32-bytes8-uint8: pass:normal[xref:#Packing-replace_32_8-bytes32-bytes8-uint8-[`++replace_32_8++`]] +:extract_32_10-bytes32-uint8: pass:normal[xref:#Packing-extract_32_10-bytes32-uint8-[`++extract_32_10++`]] +:replace_32_10-bytes32-bytes10-uint8: pass:normal[xref:#Packing-replace_32_10-bytes32-bytes10-uint8-[`++replace_32_10++`]] +:extract_32_12-bytes32-uint8: pass:normal[xref:#Packing-extract_32_12-bytes32-uint8-[`++extract_32_12++`]] +:replace_32_12-bytes32-bytes12-uint8: pass:normal[xref:#Packing-replace_32_12-bytes32-bytes12-uint8-[`++replace_32_12++`]] +:extract_32_16-bytes32-uint8: pass:normal[xref:#Packing-extract_32_16-bytes32-uint8-[`++extract_32_16++`]] +:replace_32_16-bytes32-bytes16-uint8: pass:normal[xref:#Packing-replace_32_16-bytes32-bytes16-uint8-[`++replace_32_16++`]] +:extract_32_20-bytes32-uint8: pass:normal[xref:#Packing-extract_32_20-bytes32-uint8-[`++extract_32_20++`]] +:replace_32_20-bytes32-bytes20-uint8: pass:normal[xref:#Packing-replace_32_20-bytes32-bytes20-uint8-[`++replace_32_20++`]] +:extract_32_22-bytes32-uint8: pass:normal[xref:#Packing-extract_32_22-bytes32-uint8-[`++extract_32_22++`]] +:replace_32_22-bytes32-bytes22-uint8: pass:normal[xref:#Packing-replace_32_22-bytes32-bytes22-uint8-[`++replace_32_22++`]] +:extract_32_24-bytes32-uint8: pass:normal[xref:#Packing-extract_32_24-bytes32-uint8-[`++extract_32_24++`]] +:replace_32_24-bytes32-bytes24-uint8: pass:normal[xref:#Packing-replace_32_24-bytes32-bytes24-uint8-[`++replace_32_24++`]] +:extract_32_28-bytes32-uint8: pass:normal[xref:#Packing-extract_32_28-bytes32-uint8-[`++extract_32_28++`]] +:replace_32_28-bytes32-bytes28-uint8: pass:normal[xref:#Packing-replace_32_28-bytes32-bytes28-uint8-[`++replace_32_28++`]] + [.contract] [[Packing]] -=== `++Packing++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Packing.sol[{github-icon},role=heading-link] +=== `++Packing++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Packing.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -8426,9 +9560,11 @@ _Available since v5.1._ :INVALID_INTERNAL_FUNCTION: pass:normal[xref:#Panic-INVALID_INTERNAL_FUNCTION-uint256[`++INVALID_INTERNAL_FUNCTION++`]] :panic: pass:normal[xref:#Panic-panic-uint256-[`++panic++`]] +:panic-uint256: pass:normal[xref:#Panic-panic-uint256-[`++panic++`]] + [.contract] [[Panic]] -=== `++Panic++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Panic.sol[{github-icon},role=heading-link] +=== `++Panic++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Panic.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -8546,9 +9682,12 @@ calling invalid internal function :lt: pass:normal[xref:#Comparators-lt-uint256-uint256-[`++lt++`]] :gt: pass:normal[xref:#Comparators-gt-uint256-uint256-[`++gt++`]] +:lt-uint256-uint256: pass:normal[xref:#Comparators-lt-uint256-uint256-[`++lt++`]] +:gt-uint256-uint256: pass:normal[xref:#Comparators-gt-uint256-uint256-[`++gt++`]] + [.contract] [[Comparators]] -=== `++Comparators++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.2.0/contracts/utils/Comparators.sol[{github-icon},role=heading-link] +=== `++Comparators++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/Comparators.sol[{github-icon},role=heading-link] [.hljs-theme-light.nopadding] ```solidity @@ -8575,3 +9714,125 @@ _Available since v5.1._ [[Comparators-gt-uint256-uint256-]] ==== `[.contract-item-name]#++gt++#++(uint256 a, uint256 b) → bool++` [.item-kind]#internal# +:local: pass:normal[xref:#CAIP2-local--[`++local++`]] +:format: pass:normal[xref:#CAIP2-format-string-string-[`++format++`]] +:parse: pass:normal[xref:#CAIP2-parse-string-[`++parse++`]] + +:local-: pass:normal[xref:#CAIP2-local--[`++local++`]] +:format-string-string: pass:normal[xref:#CAIP2-format-string-string-[`++format++`]] +:parse-string: pass:normal[xref:#CAIP2-parse-string-[`++parse++`]] + +[.contract] +[[CAIP2]] +=== `++CAIP2++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/CAIP2.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/utils/CAIP2.sol"; +``` + +Helper library to format and parse CAIP-2 identifiers + +https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-2.md[CAIP-2] defines chain identifiers as: +chain_id: namespace + ":" + reference +namespace: [-a-z0-9]{3,8} +reference: [-_a-zA-Z0-9]{1,32} + +WARNING: In some cases, multiple CAIP-2 identifiers may all be valid representation of a single chain. +For EVM chains, it is recommended to use `eip155:xxx` as the canonical representation (where `xxx` is +the EIP-155 chain id). Consider the possible ambiguity when processing CAIP-2 identifiers or when using them +in the context of hashes. + +[.contract-index] +.Functions +-- +* {xref-CAIP2-local--}[`++local()++`] +* {xref-CAIP2-format-string-string-}[`++format(namespace, ref)++`] +* {xref-CAIP2-parse-string-}[`++parse(caip2)++`] + +-- + +[.contract-item] +[[CAIP2-local--]] +==== `[.contract-item-name]#++local++#++() → string++` [.item-kind]#internal# + +Return the CAIP-2 identifier for the current (local) chain. + +[.contract-item] +[[CAIP2-format-string-string-]] +==== `[.contract-item-name]#++format++#++(string namespace, string ref) → string++` [.item-kind]#internal# + +Return the CAIP-2 identifier for a given namespace and reference. + +NOTE: This function does not verify that the inputs are properly formatted. + +[.contract-item] +[[CAIP2-parse-string-]] +==== `[.contract-item-name]#++parse++#++(string caip2) → string namespace, string ref++` [.item-kind]#internal# + +Parse a CAIP-2 identifier into its components. + +NOTE: This function does not verify that the CAIP-2 input is properly formatted. + +:local: pass:normal[xref:#CAIP10-local-address-[`++local++`]] +:format: pass:normal[xref:#CAIP10-format-string-string-[`++format++`]] +:parse: pass:normal[xref:#CAIP10-parse-string-[`++parse++`]] + +:local-address: pass:normal[xref:#CAIP10-local-address-[`++local++`]] +:format-string-string: pass:normal[xref:#CAIP10-format-string-string-[`++format++`]] +:parse-string: pass:normal[xref:#CAIP10-parse-string-[`++parse++`]] + +[.contract] +[[CAIP10]] +=== `++CAIP10++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v5.3.0/contracts/utils/CAIP10.sol[{github-icon},role=heading-link] + +[.hljs-theme-light.nopadding] +```solidity +import "@openzeppelin/contracts/utils/CAIP10.sol"; +``` + +Helper library to format and parse CAIP-10 identifiers + +https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-10.md[CAIP-10] defines account identifiers as: +account_id: chain_id + ":" + account_address +chain_id: [-a-z0-9]{3,8}:[-_a-zA-Z0-9]{1,32} (See {CAIP2}) +account_address: [-.%a-zA-Z0-9]{1,128} + +WARNING: According to [CAIP-10's canonicalization section](https://github.com/ChainAgnostic/CAIPs/blob/main/CAIPs/caip-10.md#canonicalization), +the implementation remains at the developer's discretion. Please note that case variations may introduce ambiguity. +For example, when building hashes to identify accounts or data associated to them, multiple representations of the +same account would derive to different hashes. For EVM chains, we recommend using checksummed addresses for the +"account_address" part. They can be generated onchain using {Strings-toChecksumHexString}. + +[.contract-index] +.Functions +-- +* {xref-CAIP10-local-address-}[`++local(account)++`] +* {xref-CAIP10-format-string-string-}[`++format(caip2, account)++`] +* {xref-CAIP10-parse-string-}[`++parse(caip10)++`] + +-- + +[.contract-item] +[[CAIP10-local-address-]] +==== `[.contract-item-name]#++local++#++(address account) → string++` [.item-kind]#internal# + +Return the CAIP-10 identifier for an account on the current (local) chain. + +[.contract-item] +[[CAIP10-format-string-string-]] +==== `[.contract-item-name]#++format++#++(string caip2, string account) → string++` [.item-kind]#internal# + +Return the CAIP-10 identifier for a given caip2 chain and account. + +NOTE: This function does not verify that the inputs are properly formatted. + +[.contract-item] +[[CAIP10-parse-string-]] +==== `[.contract-item-name]#++parse++#++(string caip10) → string caip2, string account++` [.item-kind]#internal# + +Parse a CAIP-10 identifier into its components. + +NOTE: This function does not verify that the CAIP-10 input is properly formatted. The `caip2` return can be +parsed using the {CAIP2} library. + diff --git a/docs/templates/contract.hbs b/docs/templates/contract.hbs index aaca0a3cc..458b511b0 100644 --- a/docs/templates/contract.hbs +++ b/docs/templates/contract.hbs @@ -2,6 +2,10 @@ :{{name}}: pass:normal[xref:#{{anchor}}[`++{{name}}++`]] {{/each}} +{{#each functions}} +:{{fullname}}: pass:normal[xref:#{{anchor}}[`++{{name}}++`]] +{{/each}} + [.contract] [[{{anchor}}]] === `++{{name}}++` link:https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v{{oz-version}}/{{__item_context.file.absolutePath}}[{github-icon},role=heading-link] diff --git a/docs/templates/properties.js b/docs/templates/properties.js index 52eebac54..8d6b2867d 100644 --- a/docs/templates/properties.js +++ b/docs/templates/properties.js @@ -17,6 +17,22 @@ module.exports.anchor = function anchor({ item, contract }) { return res; }; +module.exports.fullname = function fullname({ item }) { + let res = ''; + res += item.name; + if ('parameters' in item) { + const signature = item.parameters.parameters.map(v => v.typeName.typeDescriptions.typeString).join(','); + res += slug('(' + signature + ')'); + } + if (isNodeType('VariableDeclaration', item)) { + res += '-' + slug(item.typeName.typeDescriptions.typeString); + } + if (res.charAt(res.length - 1) === '-') { + return res.slice(0, -1); + } + return res; +}; + module.exports.inheritance = function ({ item, build }) { if (!isNodeType('ContractDefinition', item)) { throw new Error('used inherited-items on non-contract'); diff --git a/fv-requirements.txt b/fv-requirements.txt index 608b4de24..5aeb1225a 100644 --- a/fv-requirements.txt +++ b/fv-requirements.txt @@ -1,4 +1,4 @@ certora-cli==4.13.1 # File uses a custom name (fv-requirements.txt) so that it isn't picked by Netlify's build # whose latest Python version is 0.3.8, incompatible with most recent versions of Halmos -halmos==0.2.0 +halmos==0.2.4 diff --git a/hardhat.config.js b/hardhat.config.js index d39d3d073..30c19ca6d 100644 --- a/hardhat.config.js +++ b/hardhat.config.js @@ -90,7 +90,6 @@ module.exports = { 'initcode-size': 'off', }, '*': { - 'code-size': true, 'unused-param': !argv.coverage, // coverage causes unused-param warnings 'transient-storage': false, default: 'error', @@ -103,6 +102,7 @@ module.exports = { // we rely on the `code-size` compiler warning, that will cause a compilation error. allowUnlimitedContractSize: true, initialBaseFeePerGas: argv.coverage ? 0 : undefined, + enableRip7212: true, }, }, exposed: { diff --git a/hardhat/async-test-sanity.js b/hardhat/async-test-sanity.js index c05e5bd48..8e60f70d5 100644 --- a/hardhat/async-test-sanity.js +++ b/hardhat/async-test-sanity.js @@ -1,3 +1,10 @@ process.on('unhandledRejection', reason => { - throw new Error(reason); + // If the reason is already an Error object, throw it directly to preserve the stack trace. + if (reason instanceof Error) { + throw reason; + } else { + // If the reason is not an Error (e.g., a string, number, or other primitive), + // create a new Error object with the reason as its message. + throw new Error(`Unhandled rejection: ${reason}`); + } }); diff --git a/hardhat/common-contracts.js b/hardhat/common-contracts.js new file mode 100644 index 000000000..fd4ef1dba --- /dev/null +++ b/hardhat/common-contracts.js @@ -0,0 +1,63 @@ +const { task } = require('hardhat/config'); +const { TASK_TEST_SETUP_TEST_ENVIRONMENT } = require('hardhat/builtin-tasks/task-names'); +const { setCode } = require('@nomicfoundation/hardhat-network-helpers'); + +const fs = require('fs'); +const path = require('path'); + +const INSTANCES = { + // ERC-4337 Entrypoints + entrypoint: { + v07: { + address: '0x0000000071727De22E5E9d8BAf0edAc6f37da032', + abi: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/bin/EntryPoint070.abi'), 'utf-8')), + bytecode: fs.readFileSync(path.resolve(__dirname, '../test/bin/EntryPoint070.bytecode'), 'hex'), + }, + v08: { + address: '0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108', + abi: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/bin/EntryPoint080.abi'), 'utf-8')), + bytecode: fs.readFileSync(path.resolve(__dirname, '../test/bin/EntryPoint080.bytecode'), 'hex'), + }, + }, + senderCreator: { + v07: { + address: '0xEFC2c1444eBCC4Db75e7613d20C6a62fF67A167C', + abi: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/bin/SenderCreator070.abi'), 'utf-8')), + bytecode: fs.readFileSync(path.resolve(__dirname, '../test/bin/SenderCreator070.bytecode'), 'hex'), + }, + v08: { + address: '0x449ED7C3e6Fee6a97311d4b55475DF59C44AdD33', + abi: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../test/bin/SenderCreator080.abi'), 'utf-8')), + bytecode: fs.readFileSync(path.resolve(__dirname, '../test/bin/SenderCreator080.bytecode'), 'hex'), + }, + }, + deployer: { + // Arachnid's deterministic deployment proxy + // See: https://github.com/Arachnid/deterministic-deployment-proxy/tree/master + arachnid: { + address: '0x4e59b44847b379578588920cA78FbF26c0B4956C', + abi: [], + bytecode: + '0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3', + }, + // Micah's deployer + micah: { + address: '0x7A0D94F55792C434d74a40883C6ed8545E406D12', + abi: [], + bytecode: '0x60003681823780368234f58015156014578182fd5b80825250506014600cf3', + }, + }, +}; + +const setup = (input, ethers) => + input.address && input.abi && input.bytecode + ? setCode(input.address, '0x' + input.bytecode.replace(/0x/, '')).then(() => + ethers.getContractAt(input.abi, input.address), + ) + : Promise.all( + Object.entries(input).map(([name, entry]) => setup(entry, ethers).then(result => [name, result])), + ).then(Object.fromEntries); + +task(TASK_TEST_SETUP_TEST_ENVIRONMENT).setAction((_, env, runSuper) => + runSuper().then(() => setup(INSTANCES, env.ethers).then(result => Object.assign(env, result))), +); diff --git a/hardhat/ignore-unreachable-warnings.js b/hardhat/ignore-unreachable-warnings.js index 8e3e34340..eeacf0a1a 100644 --- a/hardhat/ignore-unreachable-warnings.js +++ b/hardhat/ignore-unreachable-warnings.js @@ -3,7 +3,7 @@ // with hardhat-ignore-warnings we are not able to selectively ignore them without potentially ignoring relevant // warnings that we don't want to miss. // Thus, we need to handle these warnings separately. We force Hardhat to compile them in a separate compilation job and -// then ignore the warnings about unreachable code that come from that compilation job. +// then ignore the warnings about unreachable code coming from that compilation job. const { task } = require('hardhat/config'); const { diff --git a/lib/forge-std b/lib/forge-std index 8f24d6b04..1eea5bae1 160000 --- a/lib/forge-std +++ b/lib/forge-std @@ -1 +1 @@ -Subproject commit 8f24d6b04c92975e0795b5868aa0d783251cdeaa +Subproject commit 1eea5bae12ae557d589f9f0f0edae2faa47cb262 diff --git a/package-lock.json b/package-lock.json index 6066b617f..e89558df7 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "openzeppelin-solidity", - "version": "5.1.0", + "version": "5.3.0-rc.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "openzeppelin-solidity", - "version": "5.1.0", + "version": "5.3.0-rc.0", "license": "MIT", "devDependencies": { "@changesets/changelog-github": "^0.5.0", @@ -24,17 +24,19 @@ "chai": "^4.2.0", "eslint": "^9.0.0", "eslint-config-prettier": "^9.0.0", - "ethers": "^6.7.1", + "ethers": "^6.13.4", "glob": "^11.0.0", "globals": "^15.3.0", "graphlib": "^2.1.8", - "hardhat": "^2.22.2", + "hardhat": "^2.22.7", "hardhat-exposed": "^0.3.15", - "hardhat-gas-reporter": "^2.0.0", + "hardhat-gas-reporter": "^2.1.0", "hardhat-ignore-warnings": "^0.2.11", + "husky": "^9.1.7", + "lint-staged": "^15.2.10", "lodash.startcase": "^4.4.0", "micromatch": "^4.0.2", - "p-limit": "^3.1.0", + "p-limit": "^6.0.0", "prettier": "^3.0.0", "prettier-plugin-solidity": "^1.1.0", "rimraf": "^6.0.0", @@ -44,7 +46,7 @@ "solidity-ast": "^0.4.50", "solidity-coverage": "^0.8.5", "solidity-docgen": "^0.6.0-beta.29", - "undici": "^6.11.1", + "undici": "^7.0.0", "yargs": "^17.0.0" } }, @@ -58,10 +60,11 @@ } }, "node_modules/@adraffy/ens-normalize": { - "version": "1.9.2", - "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.9.2.tgz", - "integrity": "sha512-0h+FrQDqe2Wn+IIGFkTCd4aAwTJ+7834Ek1COohCyV26AXhwQ7WQaz+4F/nLOeVl/3BtWHOHLPsq46V8YB46Eg==", - "dev": true + "version": "1.10.1", + "resolved": "https://registry.npmjs.org/@adraffy/ens-normalize/-/ens-normalize-1.10.1.tgz", + "integrity": "sha512-96Z2IP3mYmF1Xg2cDm8f1gWGf/HUVedQ3FMifV4kG/PQ4yEP51xDtRAEfhVNt5f/uzpNkZHwWQuUcu6D6K+Ekw==", + "dev": true, + "license": "MIT" }, "node_modules/@babel/code-frame": { "version": "7.22.13", @@ -1550,165 +1553,90 @@ } }, "node_modules/@nomicfoundation/edr": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr/-/edr-0.3.3.tgz", - "integrity": "sha512-zP+e+3B1nEUx6bW5BPnIzCQbkhmYfdMBJdiVggTqqTfAA82sOkdOG7wsOMcz5qF3fYfx/irNRM1kgc9HVFIbpQ==", + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr/-/edr-0.5.2.tgz", + "integrity": "sha512-hW/iLvUQZNTVjFyX/I40rtKvvDOqUEyIi96T28YaLfmPL+3LW2lxmYLUXEJ6MI14HzqxDqrLyhf6IbjAa2r3Dw==", "dev": true, + "license": "MIT", + "dependencies": { + "@nomicfoundation/edr-darwin-arm64": "0.5.2", + "@nomicfoundation/edr-darwin-x64": "0.5.2", + "@nomicfoundation/edr-linux-arm64-gnu": "0.5.2", + "@nomicfoundation/edr-linux-arm64-musl": "0.5.2", + "@nomicfoundation/edr-linux-x64-gnu": "0.5.2", + "@nomicfoundation/edr-linux-x64-musl": "0.5.2", + "@nomicfoundation/edr-win32-x64-msvc": "0.5.2" + }, "engines": { "node": ">= 18" - }, - "optionalDependencies": { - "@nomicfoundation/edr-darwin-arm64": "0.3.3", - "@nomicfoundation/edr-darwin-x64": "0.3.3", - "@nomicfoundation/edr-linux-arm64-gnu": "0.3.3", - "@nomicfoundation/edr-linux-arm64-musl": "0.3.3", - "@nomicfoundation/edr-linux-x64-gnu": "0.3.3", - "@nomicfoundation/edr-linux-x64-musl": "0.3.3", - "@nomicfoundation/edr-win32-arm64-msvc": "0.3.3", - "@nomicfoundation/edr-win32-ia32-msvc": "0.3.3", - "@nomicfoundation/edr-win32-x64-msvc": "0.3.3" } }, "node_modules/@nomicfoundation/edr-darwin-arm64": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-arm64/-/edr-darwin-arm64-0.3.3.tgz", - "integrity": "sha512-E9VGsUD+1Ga4mn/5ooHsMi8JEfhZbKP6CXN/BhJ8kXbIC10NqTD1RuhCKGRtYq4vqH/3Nfq25Xg8E8RWOF4KBQ==", - "cpu": [ - "arm64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-arm64/-/edr-darwin-arm64-0.5.2.tgz", + "integrity": "sha512-Gm4wOPKhbDjGTIRyFA2QUAPfCXA1AHxYOKt3yLSGJkQkdy9a5WW+qtqKeEKHc/+4wpJSLtsGQfpzyIzggFfo/A==", "dev": true, - "optional": true, - "os": [ - "darwin" - ], + "license": "MIT", "engines": { "node": ">= 18" } }, "node_modules/@nomicfoundation/edr-darwin-x64": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-x64/-/edr-darwin-x64-0.3.3.tgz", - "integrity": "sha512-vkZXZ1ydPg+Ijb2iyqENA+KCkxGTCUWG5itCSliiA0Li2YE7ujDMGhheEpFp1WVlZadviz0bfk1rZXbCqlirpg==", - "cpu": [ - "x64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-darwin-x64/-/edr-darwin-x64-0.5.2.tgz", + "integrity": "sha512-ClyABq2dFCsrYEED3/UIO0c7p4H1/4vvlswFlqUyBpOkJccr75qIYvahOSJRM62WgUFRhbSS0OJXFRwc/PwmVg==", "dev": true, - "optional": true, - "os": [ - "darwin" - ], + "license": "MIT", "engines": { "node": ">= 18" } }, "node_modules/@nomicfoundation/edr-linux-arm64-gnu": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-gnu/-/edr-linux-arm64-gnu-0.3.3.tgz", - "integrity": "sha512-gdIg0Yj1qqS9wVuywc5B/+DqKylfUGB6/CQn/shMqwAfsAVAVpchkhy66PR+REEx7fh/GkNctxLlENXPeLzDiA==", - "cpu": [ - "arm64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-gnu/-/edr-linux-arm64-gnu-0.5.2.tgz", + "integrity": "sha512-HWMTVk1iOabfvU2RvrKLDgtFjJZTC42CpHiw2h6rfpsgRqMahvIlx2jdjWYzFNy1jZKPTN1AStQ/91MRrg5KnA==", "dev": true, - "optional": true, - "os": [ - "linux" - ], + "license": "MIT", "engines": { "node": ">= 18" } }, "node_modules/@nomicfoundation/edr-linux-arm64-musl": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-musl/-/edr-linux-arm64-musl-0.3.3.tgz", - "integrity": "sha512-AXZ08MFvhNeBZbOBNmz1SJ/DMrMOE2mHEJtaNnsctlxIunjxfrWww4q+WXB34jbr9iaVYYlPsaWe5sueuw6s3Q==", - "cpu": [ - "arm64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-arm64-musl/-/edr-linux-arm64-musl-0.5.2.tgz", + "integrity": "sha512-CwsQ10xFx/QAD5y3/g5alm9+jFVuhc7uYMhrZAu9UVF+KtVjeCvafj0PaVsZ8qyijjqVuVsJ8hD1x5ob7SMcGg==", "dev": true, - "optional": true, - "os": [ - "linux" - ], + "license": "MIT", "engines": { "node": ">= 18" } }, "node_modules/@nomicfoundation/edr-linux-x64-gnu": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-gnu/-/edr-linux-x64-gnu-0.3.3.tgz", - "integrity": "sha512-xElOs1U+E6lBLtv1mnJ+E8nr2MxZgKiLo8bZAgBboy9odYtmkDVwhMjtsFKSuZbGxFtsSyGRT4cXw3JAbtUDeA==", - "cpu": [ - "x64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-gnu/-/edr-linux-x64-gnu-0.5.2.tgz", + "integrity": "sha512-CWVCEdhWJ3fmUpzWHCRnC0/VLBDbqtqTGTR6yyY1Ep3S3BOrHEAvt7h5gx85r2vLcztisu2vlDq51auie4IU1A==", "dev": true, - "optional": true, - "os": [ - "linux" - ], + "license": "MIT", "engines": { "node": ">= 18" } }, "node_modules/@nomicfoundation/edr-linux-x64-musl": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-musl/-/edr-linux-x64-musl-0.3.3.tgz", - "integrity": "sha512-2Fe6gwm1RAGQ/PfMYiaSba2OrFp8zzYWh+am9lYObOFjV9D+A1zhIzfy0UC74glPks5eV8eY4pBPrVR042m2Nw==", - "cpu": [ - "x64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-linux-x64-musl/-/edr-linux-x64-musl-0.5.2.tgz", + "integrity": "sha512-+aJDfwhkddy2pP5u1ISg3IZVAm0dO836tRlDTFWtvvSMQ5hRGqPcWwlsbobhDQsIxhPJyT7phL0orCg5W3WMeA==", "dev": true, - "optional": true, - "os": [ - "linux" - ], - "engines": { - "node": ">= 18" - } - }, - "node_modules/@nomicfoundation/edr-win32-arm64-msvc": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-win32-arm64-msvc/-/edr-win32-arm64-msvc-0.3.3.tgz", - "integrity": "sha512-8NHyxIsFrl0ufSQ/ErqF2lKIa/gz1gaaa1a2vKkDEqvqCUcPhBTYhA5NHgTPhLETFTnCFr0z+YbctFCyjh4qrA==", - "cpu": [ - "arm64" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ], - "engines": { - "node": ">= 10" - } - }, - "node_modules/@nomicfoundation/edr-win32-ia32-msvc": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-win32-ia32-msvc/-/edr-win32-ia32-msvc-0.3.3.tgz", - "integrity": "sha512-0F6hM0kGia4dQVb/kauho9JcP1ozWisY2/She+ISR5ceuhzmAwQJluM0g+0TYDME0LtxBxiMPq/yPiZMQeq31w==", - "cpu": [ - "ia32" - ], - "dev": true, - "optional": true, - "os": [ - "win32" - ], + "license": "MIT", "engines": { "node": ">= 18" } }, "node_modules/@nomicfoundation/edr-win32-x64-msvc": { - "version": "0.3.3", - "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-win32-x64-msvc/-/edr-win32-x64-msvc-0.3.3.tgz", - "integrity": "sha512-d75q1uaMb6z9i+GQZoblbOfFBvlBnWc+5rB13UWRkCOJSnoYwyFWhGJx5GeM59gC7aIblc5VD9qOAhHuvM9N+w==", - "cpu": [ - "x64" - ], + "version": "0.5.2", + "resolved": "https://registry.npmjs.org/@nomicfoundation/edr-win32-x64-msvc/-/edr-win32-x64-msvc-0.5.2.tgz", + "integrity": "sha512-CcvvuA3sAv7liFNPsIR/68YlH6rrybKzYttLlMr80d4GKJjwJ5OKb3YgE6FdZZnOfP19HEHhsLcE0DPLtY3r0w==", "dev": true, - "optional": true, - "os": [ - "win32" - ], + "license": "MIT", "engines": { "node": ">= 18" } @@ -2609,12 +2537,13 @@ "dev": true }, "node_modules/@types/node": { - "version": "20.9.0", - "resolved": "https://registry.npmjs.org/@types/node/-/node-20.9.0.tgz", - "integrity": "sha512-nekiGu2NDb1BcVofVcEKMIwzlx4NjHlcjhoxxKBNLtz15Y1z7MYf549DFvkHSId02Ax6kGwWntIBPC3l/JZcmw==", + "version": "22.7.5", + "resolved": "https://registry.npmjs.org/@types/node/-/node-22.7.5.tgz", + "integrity": "sha512-jML7s2NAzMWc//QSJ1a3prpk78cOPchGvXJsC3C6R6PSMoooztvRVQEz89gmBTBY1SPMaqo5teB4uNHPdetShQ==", "dev": true, + "license": "MIT", "dependencies": { - "undici-types": "~5.26.4" + "undici-types": "~6.19.2" } }, "node_modules/@types/normalize-package-data": { @@ -3587,6 +3516,65 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/cli-cursor": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/cli-cursor/-/cli-cursor-5.0.0.tgz", + "integrity": "sha512-aCj4O5wKyszjMmDT4tZj93kxyydN/K5zPWSCe6/0AV/AA1pqe5ZBIw0a2ZfPQV7lL5/yb5HsUreJ6UFAF1tEQw==", + "dev": true, + "dependencies": { + "restore-cursor": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-truncate": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-4.0.0.tgz", + "integrity": "sha512-nPdaFdQ0h/GEigbPClz11D0v/ZJEwxmeVZGeMo3Z5StPtUTkA9o1lD6QwoirYiSDzbcwn2XcjwmCp68W1IS4TA==", + "dev": true, + "dependencies": { + "slice-ansi": "^5.0.0", + "string-width": "^7.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/cli-truncate/node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/cli-truncate/node_modules/slice-ansi": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-5.0.0.tgz", + "integrity": "sha512-FC+lgizVPfie0kkhqUScwRu1O/lF6NOgJmlCgK+/LYxDCTk8sGelYaHDhFcDN+Sn3Cv+3VSa4Byeo+IMCzpMgQ==", + "dev": true, + "dependencies": { + "ansi-styles": "^6.0.0", + "is-fullwidth-code-point": "^4.0.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/slice-ansi?sponsor=1" + } + }, "node_modules/cliui": { "version": "8.0.1", "resolved": "https://registry.npmjs.org/cliui/-/cliui-8.0.1.tgz", @@ -3648,6 +3636,12 @@ "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", "dev": true }, + "node_modules/colorette": { + "version": "2.0.20", + "resolved": "https://registry.npmjs.org/colorette/-/colorette-2.0.20.tgz", + "integrity": "sha512-IfEDxwoWIjkeXL1eXcDiow4UbKjhLdq6/EuSVR9GMN7KVH3r9gQ83e73hsz1Nd1T3ijd5xv1wcWRYO+D6kCI2w==", + "dev": true + }, "node_modules/combined-stream": { "version": "1.0.8", "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz", @@ -3664,7 +3658,8 @@ "version": "1.2.9", "resolved": "https://registry.npmjs.org/command-exists/-/command-exists-1.2.9.tgz", "integrity": "sha512-LTQ/SGc+s0Xc0Fu5WaKnR0YiygZkm9eKFvyS+fRsU7/ZWFF8ykFM6Pc9aCVf1+xasOOZpO3BAVgVrKvsqKHV7w==", - "dev": true + "dev": true, + "license": "MIT" }, "node_modules/commander": { "version": "10.0.1", @@ -4145,6 +4140,18 @@ "node": ">=6" } }, + "node_modules/environment": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/environment/-/environment-1.1.0.tgz", + "integrity": "sha512-xUtoPkMggbz0MPyPiIWr1Kp4aeWJjDZ6SMvURhimjdZgsRuDplF5/s9hcgGhyXMhs+6vpnuoiZ2kFiu3FMnS8Q==", + "dev": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/error-ex": { "version": "1.3.2", "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", @@ -4618,6 +4625,22 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/eslint/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/eslint/node_modules/p-locate": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", @@ -4647,6 +4670,19 @@ "node": ">=8" } }, + "node_modules/eslint/node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/espree": { "version": "10.2.0", "resolved": "https://registry.npmjs.org/espree/-/espree-10.2.0.tgz", @@ -4823,9 +4859,9 @@ "dev": true }, "node_modules/ethers": { - "version": "6.7.1", - "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.7.1.tgz", - "integrity": "sha512-qX5kxIFMfg1i+epfgb0xF4WM7IqapIIu50pOJ17aebkxxa4BacW5jFrQRmCJpDEg2ZK2oNtR5QjrQ1WDBF29dA==", + "version": "6.13.4", + "resolved": "https://registry.npmjs.org/ethers/-/ethers-6.13.4.tgz", + "integrity": "sha512-21YtnZVg4/zKkCQPjrDj38B1r4nQvTZLopUGMLQ1ePU2zV/joCfDC3t3iKQjWRzjjjbzR+mdAIoikeBRNkdllA==", "dev": true, "funding": [ { @@ -4837,36 +4873,45 @@ "url": "https://www.buymeacoffee.com/ricmoo" } ], + "license": "MIT", "dependencies": { - "@adraffy/ens-normalize": "1.9.2", - "@noble/hashes": "1.1.2", - "@noble/secp256k1": "1.7.1", - "@types/node": "18.15.13", + "@adraffy/ens-normalize": "1.10.1", + "@noble/curves": "1.2.0", + "@noble/hashes": "1.3.2", + "@types/node": "22.7.5", "aes-js": "4.0.0-beta.5", - "tslib": "2.4.0", - "ws": "8.5.0" + "tslib": "2.7.0", + "ws": "8.17.1" }, "engines": { "node": ">=14.0.0" } }, - "node_modules/ethers/node_modules/@noble/hashes": { - "version": "1.1.2", - "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.1.2.tgz", - "integrity": "sha512-KYRCASVTv6aeUi1tsF8/vpyR7zpfs3FUzy2Jqm+MU+LmUKhQ0y2FpfwqkCcxSg2ua4GALJd8k2R76WxwZGbQpA==", + "node_modules/ethers/node_modules/@noble/curves": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@noble/curves/-/curves-1.2.0.tgz", + "integrity": "sha512-oYclrNgRaM9SsBUBVbb8M6DTV7ZHRTKugureoYEncY5c65HOmRzvSiTE3y5CYaPYJA/GVkrhXEoF0M3Ya9PMnw==", "dev": true, - "funding": [ - { - "type": "individual", - "url": "https://paulmillr.com/funding/" - } - ] + "license": "MIT", + "dependencies": { + "@noble/hashes": "1.3.2" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } }, - "node_modules/ethers/node_modules/@types/node": { - "version": "18.15.13", - "resolved": "https://registry.npmjs.org/@types/node/-/node-18.15.13.tgz", - "integrity": "sha512-N+0kuo9KgrUQ1Sn/ifDXsvg0TTleP7rIy4zOBGECxAljqvqfqpTfzx0Q1NUedOixRMBfe2Whhb056a42cWs26Q==", - "dev": true + "node_modules/ethers/node_modules/@noble/hashes": { + "version": "1.3.2", + "resolved": "https://registry.npmjs.org/@noble/hashes/-/hashes-1.3.2.tgz", + "integrity": "sha512-MVC8EAQp7MvEcm30KWENFjgR+Mkmf+D189XJTkFIlwohU5hcBbn1ZkKq7KVTi2Hme3PMGF390DaL52beVrIihQ==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 16" + }, + "funding": { + "url": "https://paulmillr.com/funding/" + } }, "node_modules/ethers/node_modules/aes-js": { "version": "4.0.0-beta.5", @@ -4875,22 +4920,24 @@ "dev": true }, "node_modules/ethers/node_modules/tslib": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.4.0.tgz", - "integrity": "sha512-d6xOpEDfsi2CZVlPQzGeux8XMwLT9hssAsaPYExaQMuYskwb+x1x7J371tWlbBdWHroy99KnVB6qIkUbs5X3UQ==", - "dev": true + "version": "2.7.0", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.7.0.tgz", + "integrity": "sha512-gLXCKdN1/j47AiHiOkJN69hJmcbGTHI0ImLmbYLHykhgeN0jVGola9yVjFgzCUklsZQMW55o+dW7IXv3RCXDzA==", + "dev": true, + "license": "0BSD" }, "node_modules/ethers/node_modules/ws": { - "version": "8.5.0", - "resolved": "https://registry.npmjs.org/ws/-/ws-8.5.0.tgz", - "integrity": "sha512-BWX0SWVgLPzYwF8lTzEy1egjhS4S4OEAHfsO8o65WOVsrnSRGaSiUaa9e0ggGlkMTtBlmOpEXiie9RUcBO86qg==", + "version": "8.17.1", + "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz", + "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=10.0.0" }, "peerDependencies": { "bufferutil": "^4.0.1", - "utf-8-validate": "^5.0.2" + "utf-8-validate": ">=5.0.2" }, "peerDependenciesMeta": { "bufferutil": { @@ -4935,6 +4982,12 @@ "npm": ">=3" } }, + "node_modules/eventemitter3": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/eventemitter3/-/eventemitter3-5.0.1.tgz", + "integrity": "sha512-GWkBvjiSZK87ELrYOSESUYeVIc9mvLLf/nXalMOS5dYrgZq9o5OVkbZAVM06CVxYsCwH9BDZFPlQTlPA1j4ahA==", + "dev": true + }, "node_modules/evp_bytestokey": { "version": "1.0.3", "resolved": "https://registry.npmjs.org/evp_bytestokey/-/evp_bytestokey-1.0.3.tgz", @@ -4945,6 +4998,53 @@ "safe-buffer": "^5.1.1" } }, + "node_modules/execa": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz", + "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==", + "dev": true, + "dependencies": { + "cross-spawn": "^7.0.3", + "get-stream": "^8.0.1", + "human-signals": "^5.0.0", + "is-stream": "^3.0.0", + "merge-stream": "^2.0.0", + "npm-run-path": "^5.1.0", + "onetime": "^6.0.0", + "signal-exit": "^4.1.0", + "strip-final-newline": "^3.0.0" + }, + "engines": { + "node": ">=16.17" + }, + "funding": { + "url": "https://github.com/sindresorhus/execa?sponsor=1" + } + }, + "node_modules/execa/node_modules/get-stream": { + "version": "8.0.1", + "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz", + "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==", + "dev": true, + "engines": { + "node": ">=16" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/execa/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/extendable-error": { "version": "0.1.7", "resolved": "https://registry.npmjs.org/extendable-error/-/extendable-error-0.1.7.tgz", @@ -5257,6 +5357,18 @@ "node": "6.* || 8.* || >= 10.*" } }, + "node_modules/get-east-asian-width": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/get-east-asian-width/-/get-east-asian-width-1.3.0.tgz", + "integrity": "sha512-vpeMIQKxczTD/0s2CdEWHcb0eeJe6TFjxb+J5xgX7hScxqrGuyjmv4c1D4A/gelKfyox0gJJwIHF+fLjeaM8kQ==", + "dev": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/get-func-name": { "version": "2.0.2", "resolved": "https://registry.npmjs.org/get-func-name/-/get-func-name-2.0.2.tgz", @@ -5572,14 +5684,15 @@ } }, "node_modules/hardhat": { - "version": "2.22.2", - "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.22.2.tgz", - "integrity": "sha512-0xZ7MdCZ5sJem4MrvpQWLR3R3zGDoHw5lsR+pBFimqwagimIOn3bWuZv69KA+veXClwI1s/zpqgwPwiFrd4Dxw==", + "version": "2.22.7", + "resolved": "https://registry.npmjs.org/hardhat/-/hardhat-2.22.7.tgz", + "integrity": "sha512-nrXQAl+qUr75TsCLDo8P41YXLc+5U7qQMMCIrbbmy1/uQaVPncdjDrD5BR0CENvHRj7EBqO+JkofpozXoIfJKg==", "dev": true, + "license": "MIT", "dependencies": { "@ethersproject/abi": "^5.1.2", "@metamask/eth-sig-util": "^4.0.0", - "@nomicfoundation/edr": "^0.3.1", + "@nomicfoundation/edr": "^0.5.0", "@nomicfoundation/ethereumjs-common": "4.0.4", "@nomicfoundation/ethereumjs-tx": "5.0.4", "@nomicfoundation/ethereumjs-util": "9.0.4", @@ -5613,7 +5726,7 @@ "raw-body": "^2.4.1", "resolve": "1.17.0", "semver": "^6.3.0", - "solc": "0.7.3", + "solc": "0.8.26", "source-map-support": "^0.5.13", "stacktrace-parser": "^0.1.10", "tsort": "0.0.1", @@ -5655,6 +5768,7 @@ "resolved": "https://registry.npmjs.org/hardhat-gas-reporter/-/hardhat-gas-reporter-2.1.0.tgz", "integrity": "sha512-d/WU/qHhBFnbweAm2fAAjcaaE0M7BKZ4r+/bqcFlfP6um28BXtlv2FrJ6oyQUGSFD0ttbmB7sH4ZFDzkYw5GzA==", "dev": true, + "license": "MIT", "dependencies": { "@ethersproject/abi": "^5.7.0", "@ethersproject/bytes": "^5.7.0", @@ -6030,12 +6144,6 @@ "integrity": "sha512-5tK7EtrZ0N+OLFMthtqOj4fI2Jeb88C4CAZPu25LDVUgXJ0A3Js4PMGqrn0JU1W0Mh1/Z8wZzYPxqUrXeBboCQ==", "dev": true }, - "node_modules/hardhat/node_modules/commander": { - "version": "3.0.2", - "resolved": "https://registry.npmjs.org/commander/-/commander-3.0.2.tgz", - "integrity": "sha512-Gar0ASD4BDyKC4hl4DwHqDrmvjoxWKZigVnAbn5H1owvm4CxCPdb0HQDehwNYMJpla5+M2tPmPARzhtYuwpHow==", - "dev": true - }, "node_modules/hardhat/node_modules/ethereum-cryptography": { "version": "1.2.0", "resolved": "https://registry.npmjs.org/ethereum-cryptography/-/ethereum-cryptography-1.2.0.tgz", @@ -6064,7 +6172,9 @@ "version": "7.2.0", "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.0.tgz", "integrity": "sha512-lmLf6gtyrPq8tTjSmrO94wBeQbFR3HbLHbuyD69wuyQkImp2hWqMGB47OX65FBkPffO641IP9jWa1z4ivqG26Q==", + "deprecated": "Glob versions prior to v9 are no longer supported", "dev": true, + "license": "ISC", "dependencies": { "fs.realpath": "^1.0.0", "inflight": "^1.0.4", @@ -6080,15 +6190,6 @@ "url": "https://github.com/sponsors/isaacs" } }, - "node_modules/hardhat/node_modules/jsonfile": { - "version": "2.4.0", - "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-2.4.0.tgz", - "integrity": "sha512-PKllAqbgLgxHaj8TElYymKCAgrASebJrWpTnEkOaTowt23VKXXN0sUeriJ+eh7y6ufb/CC5ap11pz71/cM0hUw==", - "dev": true, - "optionalDependencies": { - "graceful-fs": "^4.1.6" - } - }, "node_modules/hardhat/node_modules/locate-path": { "version": "2.0.0", "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-2.0.0.tgz", @@ -6144,27 +6245,6 @@ "node": ">=4" } }, - "node_modules/hardhat/node_modules/require-from-string": { - "version": "2.0.2", - "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz", - "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==", - "dev": true, - "engines": { - "node": ">=0.10.0" - } - }, - "node_modules/hardhat/node_modules/rimraf": { - "version": "2.7.1", - "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.7.1.tgz", - "integrity": "sha512-uWjbaKIK3T1OSVptzX7Nl6PvQ3qAGtKEtVRjRuazjfL3Bx5eI409VZSqgND+4UNnmzLVdPj9FqFJNPqBZFve4w==", - "dev": true, - "dependencies": { - "glob": "^7.1.3" - }, - "bin": { - "rimraf": "bin.js" - } - }, "node_modules/hardhat/node_modules/semver": { "version": "6.3.1", "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz", @@ -6174,51 +6254,6 @@ "semver": "bin/semver.js" } }, - "node_modules/hardhat/node_modules/solc": { - "version": "0.7.3", - "resolved": "https://registry.npmjs.org/solc/-/solc-0.7.3.tgz", - "integrity": "sha512-GAsWNAjGzIDg7VxzP6mPjdurby3IkGCjQcM8GFYZT6RyaoUZKmMU6Y7YwG+tFGhv7dwZ8rmR4iwFDrrD99JwqA==", - "dev": true, - "dependencies": { - "command-exists": "^1.2.8", - "commander": "3.0.2", - "follow-redirects": "^1.12.1", - "fs-extra": "^0.30.0", - "js-sha3": "0.8.0", - "memorystream": "^0.3.1", - "require-from-string": "^2.0.0", - "semver": "^5.5.0", - "tmp": "0.0.33" - }, - "bin": { - "solcjs": "solcjs" - }, - "engines": { - "node": ">=8.0.0" - } - }, - "node_modules/hardhat/node_modules/solc/node_modules/fs-extra": { - "version": "0.30.0", - "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-0.30.0.tgz", - "integrity": "sha512-UvSPKyhMn6LEd/WpUaV9C9t3zATuqoqfWc3QdPhPLb58prN9tqYPlPWi8Krxi44loBoUzlobqZ3+8tGpxxSzwA==", - "dev": true, - "dependencies": { - "graceful-fs": "^4.1.2", - "jsonfile": "^2.1.0", - "klaw": "^1.0.0", - "path-is-absolute": "^1.0.0", - "rimraf": "^2.2.8" - } - }, - "node_modules/hardhat/node_modules/solc/node_modules/semver": { - "version": "5.7.2", - "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", - "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", - "dev": true, - "bin": { - "semver": "bin/semver" - } - }, "node_modules/hardhat/node_modules/undici": { "version": "5.28.4", "resolved": "https://registry.npmjs.org/undici/-/undici-5.28.4.tgz", @@ -6446,6 +6481,30 @@ "integrity": "sha512-UNopramDEhHJD+VR+ehk8rOslwSfByxPIZyJRfV739NDhN5LF1fa1MqnzKm2lGTQRjNrjK19Q5fhkgIfjlVUKw==", "dev": true }, + "node_modules/human-signals": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz", + "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==", + "dev": true, + "engines": { + "node": ">=16.17.0" + } + }, + "node_modules/husky": { + "version": "9.1.7", + "resolved": "https://registry.npmjs.org/husky/-/husky-9.1.7.tgz", + "integrity": "sha512-5gs5ytaNjBrh5Ow3zrvdUUY+0VxIuWVL4i9irt6friV+BqdCfmV11CQTWMiBYWHbXhco+J1kHfTOUkePhCDvMA==", + "dev": true, + "bin": { + "husky": "bin.js" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/typicode" + } + }, "node_modules/iconv-lite": { "version": "0.4.24", "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz", @@ -6678,6 +6737,18 @@ "node": ">=0.10.0" } }, + "node_modules/is-fullwidth-code-point": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-4.0.0.tgz", + "integrity": "sha512-O4L094N2/dZ7xqVdrXhh9r1KODPJpFms8B5sGdJLPy664AgvXsreZUyCQQNItZRDlYug4xStLjNp/sz3HvBowQ==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/is-glob": { "version": "4.0.3", "resolved": "https://registry.npmjs.org/is-glob/-/is-glob-4.0.3.tgz", @@ -6782,6 +6853,18 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/is-stream": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz", + "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==", + "dev": true, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/is-string": { "version": "1.0.7", "resolved": "https://registry.npmjs.org/is-string/-/is-string-1.0.7.tgz", @@ -7019,15 +7102,6 @@ "node": ">=0.10.0" } }, - "node_modules/klaw": { - "version": "1.3.1", - "resolved": "https://registry.npmjs.org/klaw/-/klaw-1.3.1.tgz", - "integrity": "sha512-TED5xi9gGQjGpNnvRWknrwAB1eL5GciPfVFOt3Vk1OJCVDQbzuSfrF3hkUQKlsgKrG1F+0t5W0m+Fje1jIt8rw==", - "dev": true, - "optionalDependencies": { - "graceful-fs": "^4.1.9" - } - }, "node_modules/kleur": { "version": "4.1.5", "resolved": "https://registry.npmjs.org/kleur/-/kleur-4.1.5.tgz", @@ -7065,12 +7139,168 @@ "node": ">= 0.8.0" } }, + "node_modules/lilconfig": { + "version": "3.1.3", + "resolved": "https://registry.npmjs.org/lilconfig/-/lilconfig-3.1.3.tgz", + "integrity": "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw==", + "dev": true, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/antonk52" + } + }, "node_modules/lines-and-columns": { "version": "1.2.4", "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", "dev": true }, + "node_modules/lint-staged": { + "version": "15.2.10", + "resolved": "https://registry.npmjs.org/lint-staged/-/lint-staged-15.2.10.tgz", + "integrity": "sha512-5dY5t743e1byO19P9I4b3x8HJwalIznL5E1FWYnU6OWw33KxNBSLAc6Cy7F2PsFEO8FKnLwjwm5hx7aMF0jzZg==", + "dev": true, + "dependencies": { + "chalk": "~5.3.0", + "commander": "~12.1.0", + "debug": "~4.3.6", + "execa": "~8.0.1", + "lilconfig": "~3.1.2", + "listr2": "~8.2.4", + "micromatch": "~4.0.8", + "pidtree": "~0.6.0", + "string-argv": "~0.3.2", + "yaml": "~2.5.0" + }, + "bin": { + "lint-staged": "bin/lint-staged.js" + }, + "engines": { + "node": ">=18.12.0" + }, + "funding": { + "url": "https://opencollective.com/lint-staged" + } + }, + "node_modules/lint-staged/node_modules/chalk": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.3.0.tgz", + "integrity": "sha512-dLitG79d+GV1Nb/VYcCDFivJeK1hiukt9QjRNVOsUtTy1rR1YJsmpGGTZ3qJos+uw7WmWF4wUwBd9jxjocFC2w==", + "dev": true, + "engines": { + "node": "^12.17.0 || ^14.13 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/chalk/chalk?sponsor=1" + } + }, + "node_modules/lint-staged/node_modules/commander": { + "version": "12.1.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-12.1.0.tgz", + "integrity": "sha512-Vw8qHK3bZM9y/P10u3Vib8o/DdkvA2OtPtZvD871QKjy74Wj1WSKFILMPRPSdUSx5RFK1arlJzEtA4PkFgnbuA==", + "dev": true, + "engines": { + "node": ">=18" + } + }, + "node_modules/lint-staged/node_modules/debug": { + "version": "4.3.7", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz", + "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==", + "dev": true, + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/lint-staged/node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "dev": true + }, + "node_modules/listr2": { + "version": "8.2.5", + "resolved": "https://registry.npmjs.org/listr2/-/listr2-8.2.5.tgz", + "integrity": "sha512-iyAZCeyD+c1gPyE9qpFu8af0Y+MRtmKOncdGoA2S5EY8iFq99dmmvkNnHiWo+pj0s7yH7l3KPIgee77tKpXPWQ==", + "dev": true, + "dependencies": { + "cli-truncate": "^4.0.0", + "colorette": "^2.0.20", + "eventemitter3": "^5.0.1", + "log-update": "^6.1.0", + "rfdc": "^1.4.1", + "wrap-ansi": "^9.0.0" + }, + "engines": { + "node": ">=18.0.0" + } + }, + "node_modules/listr2/node_modules/ansi-regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/listr2/node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/listr2/node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dev": true, + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/listr2/node_modules/wrap-ansi": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz", + "integrity": "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^6.2.1", + "string-width": "^7.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, "node_modules/load-yaml-file": { "version": "0.2.0", "resolved": "https://registry.npmjs.org/load-yaml-file/-/load-yaml-file-0.2.0.tgz", @@ -7214,6 +7444,127 @@ "node": ">=8" } }, + "node_modules/log-update": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/log-update/-/log-update-6.1.0.tgz", + "integrity": "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w==", + "dev": true, + "dependencies": { + "ansi-escapes": "^7.0.0", + "cli-cursor": "^5.0.0", + "slice-ansi": "^7.1.0", + "strip-ansi": "^7.1.0", + "wrap-ansi": "^9.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-update/node_modules/ansi-escapes": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.0.0.tgz", + "integrity": "sha512-GdYO7a61mR0fOlAsvC9/rIHf7L96sBc6dEWzeOu+KAea5bZyQRPIpojrVoI4AXGJS/ycu/fBTdLrUkA4ODrvjw==", + "dev": true, + "dependencies": { + "environment": "^1.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-update/node_modules/ansi-regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/log-update/node_modules/ansi-styles": { + "version": "6.2.1", + "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-6.2.1.tgz", + "integrity": "sha512-bN798gFfQX+viw3R7yrGWRqnrN2oRkEkUjjl4JNn4E8GxxbjtG3FbrEIIY3l8/hrwUwIeCZvi4QuOTP4MErVug==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-styles?sponsor=1" + } + }, + "node_modules/log-update/node_modules/is-fullwidth-code-point": { + "version": "5.0.0", + "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-5.0.0.tgz", + "integrity": "sha512-OVa3u9kkBbw7b8Xw5F9P+D/T9X+Z4+JruYVNapTjPYZYUznQ5YfWeFkOj606XYYW8yugTfC8Pj0hYqvi4ryAhA==", + "dev": true, + "dependencies": { + "get-east-asian-width": "^1.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/log-update/node_modules/slice-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-7.1.0.tgz", + "integrity": "sha512-bSiSngZ/jWeX93BqeIAbImyTbEihizcwNjFoRUIY/T1wWQsfsm2Vw1agPKylXvQTU7iASGdHhyqRlqQzfz+Htg==", + "dev": true, + "dependencies": { + "ansi-styles": "^6.2.1", + "is-fullwidth-code-point": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/slice-ansi?sponsor=1" + } + }, + "node_modules/log-update/node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dev": true, + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, + "node_modules/log-update/node_modules/wrap-ansi": { + "version": "9.0.0", + "resolved": "https://registry.npmjs.org/wrap-ansi/-/wrap-ansi-9.0.0.tgz", + "integrity": "sha512-G8ura3S+3Z2G+mkgNRq8dqaFZAuxfsxpBB8OCTGRTCtp+l/v9nbFNmCUP1BZMts3G1142MsZfn6eeUKrr4PD1Q==", + "dev": true, + "dependencies": { + "ansi-styles": "^6.2.1", + "string-width": "^7.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/chalk/wrap-ansi?sponsor=1" + } + }, "node_modules/loupe": { "version": "2.3.6", "resolved": "https://registry.npmjs.org/loupe/-/loupe-2.3.6.tgz", @@ -7328,6 +7679,12 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/merge-stream": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz", + "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==", + "dev": true + }, "node_modules/merge2": { "version": "1.4.1", "resolved": "https://registry.npmjs.org/merge2/-/merge2-1.4.1.tgz", @@ -7344,12 +7701,12 @@ "dev": true }, "node_modules/micromatch": { - "version": "4.0.5", - "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.5.tgz", - "integrity": "sha512-DMy+ERcEW2q8Z2Po+WNXuw3c5YaUSFjAO5GsJqfEl7UjvtIuFKO6ZrKvcItdy98dwFI2N1tg3zNIdKaQT+aNdA==", + "version": "4.0.8", + "resolved": "https://registry.npmjs.org/micromatch/-/micromatch-4.0.8.tgz", + "integrity": "sha512-PXwfBhYu0hBCPw8Dn0E+WDYb7af3dSLVWKi3HGv84IdF4TyFoC0ysxFd0Goxw7nSv4T/PzEJQxsYsEiFCKo2BA==", "dev": true, "dependencies": { - "braces": "^3.0.2", + "braces": "^3.0.3", "picomatch": "^2.3.1" }, "engines": { @@ -7377,6 +7734,30 @@ "node": ">= 0.6" } }, + "node_modules/mimic-fn": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz", + "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/mimic-function": { + "version": "5.0.1", + "resolved": "https://registry.npmjs.org/mimic-function/-/mimic-function-5.0.1.tgz", + "integrity": "sha512-VP79XUPxV2CigYP3jWwAUFSku2aKqBH7uTAapFWCBqutsbmDo96KY5o8uh6U+/YSIn5OxJnXp73beVkpqMIGhA==", + "dev": true, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/mimic-response": { "version": "4.0.0", "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-4.0.0.tgz", @@ -7683,6 +8064,22 @@ "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", "dev": true }, + "node_modules/mocha/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/mocha/node_modules/p-locate": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", @@ -7754,6 +8151,19 @@ "node": ">=10" } }, + "node_modules/mocha/node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/ms": { "version": "2.1.2", "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.2.tgz", @@ -7905,6 +8315,33 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/npm-run-path": { + "version": "5.3.0", + "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz", + "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==", + "dev": true, + "dependencies": { + "path-key": "^4.0.0" + }, + "engines": { + "node": "^12.20.0 || ^14.13.1 || >=16.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/npm-run-path/node_modules/path-key": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz", + "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/number-to-bn": { "version": "1.7.0", "resolved": "https://registry.npmjs.org/number-to-bn/-/number-to-bn-1.7.0.tgz", @@ -7976,6 +8413,21 @@ "wrappy": "1" } }, + "node_modules/onetime": { + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz", + "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==", + "dev": true, + "dependencies": { + "mimic-fn": "^4.0.0" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/optionator": { "version": "0.9.3", "resolved": "https://registry.npmjs.org/optionator/-/optionator-0.9.3.tgz", @@ -8045,15 +8497,16 @@ } }, "node_modules/p-limit": { - "version": "3.1.0", - "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", - "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "version": "6.0.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-6.0.0.tgz", + "integrity": "sha512-Dx+NzOuILWwjJE9OYtEKuQRy0i3c5QVAmDsVrvvRSgyNnPuB27D2DyEjl6QTNyeePaAHjaPk+ya0yA0Frld8RA==", "dev": true, + "license": "MIT", "dependencies": { - "yocto-queue": "^0.1.0" + "yocto-queue": "^1.1.1" }, "engines": { - "node": ">=10" + "node": ">=18" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -8261,6 +8714,18 @@ "url": "https://github.com/sponsors/jonschlinkert" } }, + "node_modules/pidtree": { + "version": "0.6.0", + "resolved": "https://registry.npmjs.org/pidtree/-/pidtree-0.6.0.tgz", + "integrity": "sha512-eG2dWTVw5bzqGRztnHExczNxt5VGsE6OwTeCG3fdUf9KBsZzO3R5OIIIzWR+iZA0NtZ+RDVdaoE2dK1cn6jH4g==", + "dev": true, + "bin": { + "pidtree": "bin/pidtree.js" + }, + "engines": { + "node": ">=0.10" + } + }, "node_modules/pify": { "version": "4.0.1", "resolved": "https://registry.npmjs.org/pify/-/pify-4.0.1.tgz", @@ -8337,6 +8802,22 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/preferred-pm/node_modules/p-limit": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", + "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", + "dev": true, + "license": "MIT", + "dependencies": { + "yocto-queue": "^0.1.0" + }, + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/preferred-pm/node_modules/p-locate": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", @@ -8352,6 +8833,19 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/preferred-pm/node_modules/yocto-queue": { + "version": "0.1.0", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", + "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/prelude-ls": { "version": "1.2.1", "resolved": "https://registry.npmjs.org/prelude-ls/-/prelude-ls-1.2.1.tgz", @@ -8773,6 +9267,49 @@ "url": "https://github.com/sponsors/sindresorhus" } }, + "node_modules/restore-cursor": { + "version": "5.1.0", + "resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz", + "integrity": "sha512-oMA2dcrw6u0YfxJQXm342bFKX/E4sG9rbTzO9ptUcR/e8A33cHuvStiYOwH7fszkZlZ1z/ta9AAoPk2F4qIOHA==", + "dev": true, + "dependencies": { + "onetime": "^7.0.0", + "signal-exit": "^4.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/restore-cursor/node_modules/onetime": { + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/onetime/-/onetime-7.0.0.tgz", + "integrity": "sha512-VXJjc87FScF88uafS3JllDgvAm+c/Slfz06lorj2uAY34rlUu0Nt+v8wreiImcrgAjjIHp1rXpTDlLOGw29WwQ==", + "dev": true, + "dependencies": { + "mimic-function": "^5.0.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/restore-cursor/node_modules/signal-exit": { + "version": "4.1.0", + "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-4.1.0.tgz", + "integrity": "sha512-bzyZ1e88w9O1iNJbKnOlvYTrWPDl46O1bG0D3XInv+9tkPrxrN8jUUTiFlDkkmKWgn1M6CfIA13SuGqOa9Korw==", + "dev": true, + "engines": { + "node": ">=14" + }, + "funding": { + "url": "https://github.com/sponsors/isaacs" + } + }, "node_modules/retry": { "version": "0.12.0", "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz", @@ -8792,6 +9329,12 @@ "node": ">=0.10.0" } }, + "node_modules/rfdc": { + "version": "1.4.1", + "resolved": "https://registry.npmjs.org/rfdc/-/rfdc-1.4.1.tgz", + "integrity": "sha512-q1b3N5QkRUWUl7iyylaaj3kOpIT0N2i9MqIEQXP73GVsN9cw3fdx8X63cEmWhJGi2PPCF23Ijp7ktmd39rawIA==", + "dev": true + }, "node_modules/rimraf": { "version": "6.0.0", "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.0.0.tgz", @@ -9457,6 +10000,48 @@ "node": ">=8" } }, + "node_modules/solc": { + "version": "0.8.26", + "resolved": "https://registry.npmjs.org/solc/-/solc-0.8.26.tgz", + "integrity": "sha512-yiPQNVf5rBFHwN6SIf3TUUvVAFKcQqmSUFeq+fb6pNRCo0ZCgpYOZDi3BVoezCPIAcKrVYd/qXlBLUP9wVrZ9g==", + "dev": true, + "license": "MIT", + "dependencies": { + "command-exists": "^1.2.8", + "commander": "^8.1.0", + "follow-redirects": "^1.12.1", + "js-sha3": "0.8.0", + "memorystream": "^0.3.1", + "semver": "^5.5.0", + "tmp": "0.0.33" + }, + "bin": { + "solcjs": "solc.js" + }, + "engines": { + "node": ">=10.0.0" + } + }, + "node_modules/solc/node_modules/commander": { + "version": "8.3.0", + "resolved": "https://registry.npmjs.org/commander/-/commander-8.3.0.tgz", + "integrity": "sha512-OkTL9umf+He2DZkUq8f8J9of7yL6RJKI24dVITBmNfZBmri9zYZQrKkuXiKhyfPSu8tUhnVBB1iKXevvnlR4Ww==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">= 12" + } + }, + "node_modules/solc/node_modules/semver": { + "version": "5.7.2", + "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz", + "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==", + "dev": true, + "license": "ISC", + "bin": { + "semver": "bin/semver" + } + }, "node_modules/solhint": { "version": "5.0.0", "resolved": "https://registry.npmjs.org/solhint/-/solhint-5.0.0.tgz", @@ -10130,6 +10715,32 @@ "safe-buffer": "~5.2.0" } }, + "node_modules/string-argv": { + "version": "0.3.2", + "resolved": "https://registry.npmjs.org/string-argv/-/string-argv-0.3.2.tgz", + "integrity": "sha512-aqD2Q0144Z+/RqG52NeHEkZauTAUWJO8c6yTftGJKO3Tja5tUgIfmIl6kExvhtxSDP7fXB6DvzkfMpCd/F3G+Q==", + "dev": true, + "engines": { + "node": ">=0.6.19" + } + }, + "node_modules/string-width": { + "version": "7.2.0", + "resolved": "https://registry.npmjs.org/string-width/-/string-width-7.2.0.tgz", + "integrity": "sha512-tsaTIkKW9b4N+AEj+SVA+WhJzV7/zMhcSu78mLKWSk7cXMOSHsBKFWUs0fWwq8QyK3MgJBQRX6Gbi4kYbdvGkQ==", + "dev": true, + "dependencies": { + "emoji-regex": "^10.3.0", + "get-east-asian-width": "^1.0.0", + "strip-ansi": "^7.1.0" + }, + "engines": { + "node": ">=18" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/string-width-cjs": { "name": "string-width", "version": "4.2.3", @@ -10154,6 +10765,39 @@ "node": ">=8" } }, + "node_modules/string-width/node_modules/ansi-regex": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/ansi-regex/-/ansi-regex-6.1.0.tgz", + "integrity": "sha512-7HSX4QQb4CspciLpVFwyRe79O3xsIZDDLER21kERQ71oaPodF8jL725AgJMFAYbooIqolJoRLuM81SpeUkpkvA==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/ansi-regex?sponsor=1" + } + }, + "node_modules/string-width/node_modules/emoji-regex": { + "version": "10.4.0", + "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-10.4.0.tgz", + "integrity": "sha512-EC+0oUMY1Rqm4O6LLrgjtYDvcVYTy7chDnM4Q7030tP4Kwj3u/pR6gP9ygnp2CJMK5Gq+9Q2oqmrFJAz01DXjw==", + "dev": true + }, + "node_modules/string-width/node_modules/strip-ansi": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-7.1.0.tgz", + "integrity": "sha512-iq6eVVI64nQQTRYq2KtEg2d2uU7LElhTJwsH4YzIHZshxlgZms/wIc4VoDQTlG/IvVIrBKG06CrZnp0qv7hkcQ==", + "dev": true, + "dependencies": { + "ansi-regex": "^6.0.1" + }, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/chalk/strip-ansi?sponsor=1" + } + }, "node_modules/string.prototype.trim": { "version": "1.2.8", "resolved": "https://registry.npmjs.org/string.prototype.trim/-/string.prototype.trim-1.2.8.tgz", @@ -10233,6 +10877,18 @@ "node": ">=4" } }, + "node_modules/strip-final-newline": { + "version": "3.0.0", + "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz", + "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==", + "dev": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, "node_modules/strip-hex-prefix": { "version": "1.0.0", "resolved": "https://registry.npmjs.org/strip-hex-prefix/-/strip-hex-prefix-1.0.0.tgz", @@ -10719,19 +11375,21 @@ } }, "node_modules/undici": { - "version": "6.12.0", - "resolved": "https://registry.npmjs.org/undici/-/undici-6.12.0.tgz", - "integrity": "sha512-d87yk8lqSFUYtR5fTFe2frpkMIrUEz+lgoJmhcL+J3StVl+8fj8ytE4lLnJOTPCE12YbumNGzf4LYsQyusdV5g==", + "version": "7.0.0", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.0.0.tgz", + "integrity": "sha512-c4xi3kWnQJrb7h2q8aJYKvUzmz7boCgz1cUCC6OwdeM5Tr2P0hDuthr2iut4ggqsz+Cnh20U/LoTzbKIdDS/Nw==", "dev": true, + "license": "MIT", "engines": { - "node": ">=18.0" + "node": ">=20.18.1" } }, "node_modules/undici-types": { - "version": "5.26.5", - "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-5.26.5.tgz", - "integrity": "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA==", - "dev": true + "version": "6.19.8", + "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.19.8.tgz", + "integrity": "sha512-ve2KP6f/JnbPBFyobGHuerC9g1FYGn/F8n1LWTwNxCEzd6IfqTwUQcNXgEtmmQ6DlRrC1hrSrBnCZPokRrDHjw==", + "dev": true, + "license": "MIT" }, "node_modules/universalify": { "version": "0.1.2", @@ -11250,10 +11908,11 @@ "dev": true }, "node_modules/ws": { - "version": "7.5.9", - "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.9.tgz", - "integrity": "sha512-F+P9Jil7UiSKSkppIiD94dN07AwvFixvLIj1Og1Rl9GGMuNipJnV9JzjD6XuqmAeiswGvUmNLjr5cFuXwNS77Q==", + "version": "7.5.10", + "resolved": "https://registry.npmjs.org/ws/-/ws-7.5.10.tgz", + "integrity": "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ==", "dev": true, + "license": "MIT", "engines": { "node": ">=8.3.0" }, @@ -11279,6 +11938,18 @@ "node": ">=10" } }, + "node_modules/yaml": { + "version": "2.5.1", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-2.5.1.tgz", + "integrity": "sha512-bLQOjaX/ADgQ20isPJRvF0iRUHIxVhYvr53Of7wGcWlO2jvtUlH5m87DsmulFVxRpNLOnI4tB6p/oh8D7kpn9Q==", + "dev": true, + "bin": { + "yaml": "bin.mjs" + }, + "engines": { + "node": ">= 14" + } + }, "node_modules/yargs": { "version": "17.7.2", "resolved": "https://registry.npmjs.org/yargs/-/yargs-17.7.2.tgz", @@ -11399,12 +12070,13 @@ } }, "node_modules/yocto-queue": { - "version": "0.1.0", - "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", - "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-1.1.1.tgz", + "integrity": "sha512-b4JR1PFR10y1mKjhHY9LaGo6tmrgjit7hxVIeAmyMw3jegXR4dhYqLaQF5zMXZxY7tLpMyJeLjr1C4rLmkVe8g==", "dev": true, + "license": "MIT", "engines": { - "node": ">=10" + "node": ">=12.20" }, "funding": { "url": "https://github.com/sponsors/sindresorhus" @@ -11413,7 +12085,10 @@ "scripts/solhint-custom": { "name": "solhint-plugin-openzeppelin", "version": "0.0.0", - "dev": true + "dev": true, + "dependencies": { + "minimatch": "^3.1.2" + } } } } diff --git a/package.json b/package.json index 4db5ac0a1..2096a0877 100644 --- a/package.json +++ b/package.json @@ -1,7 +1,7 @@ { "name": "openzeppelin-solidity", "description": "Secure Smart Contract library for Solidity", - "version": "5.2.0", + "version": "5.3.0", "private": true, "files": [ "/contracts/**/*.sol", @@ -13,7 +13,7 @@ "coverage": "scripts/checks/coverage.sh", "docs": "npm run prepare-docs && oz-docs", "docs:watch": "oz-docs watch contracts docs/templates docs/config.js", - "prepare": "scripts/prepare.sh", + "prepare": "husky", "prepare-docs": "scripts/prepare-docs.sh", "lint": "npm run lint:js && npm run lint:sol", "lint:fix": "npm run lint:js:fix && npm run lint:sol:fix", @@ -25,7 +25,7 @@ "prepack": "scripts/prepack.sh", "generate": "scripts/generate/run.js", "version": "scripts/release/version.sh", - "test": "hardhat test", + "test": ". scripts/set-max-old-space-size.sh && hardhat test", "test:generation": "scripts/checks/generation.sh", "test:inheritance": "scripts/checks/inheritance-ordering.js artifacts/build-info/*", "test:pragma": "scripts/checks/pragma-consistency.js artifacts/build-info/*", @@ -66,17 +66,19 @@ "chai": "^4.2.0", "eslint": "^9.0.0", "eslint-config-prettier": "^9.0.0", - "ethers": "^6.7.1", - "globals": "^15.3.0", + "ethers": "^6.13.4", "glob": "^11.0.0", + "globals": "^15.3.0", "graphlib": "^2.1.8", - "hardhat": "^2.22.2", + "hardhat": "^2.22.7", "hardhat-exposed": "^0.3.15", - "hardhat-gas-reporter": "^2.0.0", + "hardhat-gas-reporter": "^2.1.0", "hardhat-ignore-warnings": "^0.2.11", + "husky": "^9.1.7", + "lint-staged": "^15.2.10", "lodash.startcase": "^4.4.0", "micromatch": "^4.0.2", - "p-limit": "^3.1.0", + "p-limit": "^6.0.0", "prettier": "^3.0.0", "prettier-plugin-solidity": "^1.1.0", "rimraf": "^6.0.0", @@ -86,7 +88,17 @@ "solidity-ast": "^0.4.50", "solidity-coverage": "^0.8.5", "solidity-docgen": "^0.6.0-beta.29", - "undici": "^6.11.1", + "undici": "^7.0.0", "yargs": "^17.0.0" + }, + "lint-staged": { + "*.{js,ts}": [ + "prettier --log-level warn --ignore-path .gitignore --check", + "eslint" + ], + "*.sol": [ + "prettier --log-level warn --ignore-path .gitignore --check", + "solhint" + ] } } diff --git a/scripts/checks/coverage.sh b/scripts/checks/coverage.sh index a591069c4..fd8b9e843 100755 --- a/scripts/checks/coverage.sh +++ b/scripts/checks/coverage.sh @@ -5,6 +5,8 @@ set -euo pipefail export COVERAGE=true export FOUNDRY_FUZZ_RUNS=10 +. scripts/set-max-old-space-size.sh + # Hardhat coverage hardhat coverage @@ -12,7 +14,11 @@ if [ "${CI:-"false"}" == "true" ]; then # Foundry coverage forge coverage --report lcov --ir-minimum # Remove zero hits - sed -i '/,0/d' lcov.info + if [[ "$OSTYPE" == "darwin"* ]]; then + sed -i '' '/,0/d' lcov.info + else + sed -i '/,0/d' lcov.info + fi fi # Reports are then uploaded to Codecov automatically by workflow, and merged. diff --git a/scripts/checks/inheritance-ordering.js b/scripts/checks/inheritance-ordering.js index 4ed2deec4..fbeac9ea7 100755 --- a/scripts/checks/inheritance-ordering.js +++ b/scripts/checks/inheritance-ordering.js @@ -31,7 +31,7 @@ for (const artifact of artifacts) { } /// graphlib.alg.findCycles will not find minimal cycles. - /// We are only interested int cycles of lengths 2 (needs proof) + /// We are only interested in cycles of lengths 2 (needs proof) graph.nodes().forEach((x, i, nodes) => nodes .slice(i + 1) diff --git a/scripts/checks/pragma-consistency.js b/scripts/checks/pragma-consistency.js index f2f3c548f..cf74cd27a 100755 --- a/scripts/checks/pragma-consistency.js +++ b/scripts/checks/pragma-consistency.js @@ -31,7 +31,7 @@ for (const artifact of artifacts) { const minVersion = semver.minVersion(pragma[source]); // loop over all imports in source for (const { absolutePath } of findAll('ImportDirective', solcOutput.sources[source].ast)) { - // So files that only import without declaring anything cause issues, because they don't shop in in "pragma" + // So files that only import without declaring anything cause issues, because they don't shop in "pragma" if (!pragma[absolutePath]) continue; // Check that the minVersion for source satisfies the requirements of the imported files if (!semver.satisfies(minVersion, pragma[absolutePath])) { diff --git a/scripts/fetch-common-contracts.js b/scripts/fetch-common-contracts.js new file mode 100755 index 000000000..af904243b --- /dev/null +++ b/scripts/fetch-common-contracts.js @@ -0,0 +1,50 @@ +#!/usr/bin/env node + +// This script snapshots the bytecode and ABI for the `hardhat/common-contracts.js` script. +// - Bytecode is fetched directly from the blockchain by querying the provided client endpoint. If no endpoint is +// provided, ethers default provider is used instead. +// - ABI is fetched from etherscan's API using the provided etherscan API key. If no API key is provided, ABI will not +// be fetched and saved. +// +// The produced artifacts are stored in the `output` folder ('test/bin' by default). For each contract, two files are +// produced: +// - `.bytecode` containing the contract bytecode (in binary encoding) +// - `.abi` containing the ABI (in utf-8 encoding) + +const fs = require('fs'); +const path = require('path'); +const { ethers } = require('ethers'); +const { request } = require('undici'); +const { hideBin } = require('yargs/helpers'); +const { argv } = require('yargs/yargs')(hideBin(process.argv)) + .env('') + .options({ + output: { type: 'string', default: 'test/bin/' }, + client: { type: 'string' }, + etherscan: { type: 'string' }, + }); + +// List of contract names and addresses to fetch +const config = { + EntryPoint070: '0x0000000071727De22E5E9d8BAf0edAc6f37da032', + SenderCreator070: '0xEFC2c1444eBCC4Db75e7613d20C6a62fF67A167C', + EntryPoint080: '0x4337084D9E255Ff0702461CF8895CE9E3b5Ff108', + SenderCreator080: '0x449ED7C3e6Fee6a97311d4b55475DF59C44AdD33', +}; + +Promise.all( + Object.entries(config).flatMap(([name, addr]) => + Promise.all([ + argv.etherscan && + request(`https://api.etherscan.io/api?module=contract&action=getabi&address=${addr}&apikey=${argv.etherscan}`) + .then(({ body }) => body.json()) + .then(({ result: abi }) => fs.writeFile(path.join(argv.output, `${name}.abi`), abi, 'utf-8', () => {})), + ethers + .getDefaultProvider(argv.client) + .getCode(addr) + .then(bytecode => + fs.writeFile(path.join(argv.output, `${name}.bytecode`), ethers.getBytes(bytecode), 'binary', () => {}), + ), + ]), + ), +); diff --git a/scripts/generate/templates/Arrays.js b/scripts/generate/templates/Arrays.js index 0d3676a72..6b3a9a6a3 100644 --- a/scripts/generate/templates/Arrays.js +++ b/scripts/generate/templates/Arrays.js @@ -346,7 +346,7 @@ function unsafeMemoryAccess(${type}[] memory arr, uint256 pos) internal pure ret const unsafeSetLength = type => `\ /** - * @dev Helper to set the length of an dynamic array. Directly writing to \`.length\` is forbidden. + * @dev Helper to set the length of a dynamic array. Directly writing to \`.length\` is forbidden. * * WARNING: this does not clear elements if length is reduced, of initialize elements if length is increased. */ diff --git a/scripts/generate/templates/Checkpoints.js b/scripts/generate/templates/Checkpoints.js index 7ec4a7253..eb0f5c8f3 100644 --- a/scripts/generate/templates/Checkpoints.js +++ b/scripts/generate/templates/Checkpoints.js @@ -119,7 +119,7 @@ function latestCheckpoint(${opts.historyTypeName} storage self) internal view re } /** - * @dev Returns the number of checkpoint. + * @dev Returns the number of checkpoints. */ function length(${opts.historyTypeName} storage self) internal view returns (uint256) { return self.${opts.checkpointFieldName}.length; diff --git a/scripts/generate/templates/Checkpoints.t.js b/scripts/generate/templates/Checkpoints.t.js index edd2e9f98..77a9cd31a 100644 --- a/scripts/generate/templates/Checkpoints.t.js +++ b/scripts/generate/templates/Checkpoints.t.js @@ -14,7 +14,7 @@ import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol const template = opts => `\ using Checkpoints for Checkpoints.${opts.historyTypeName}; -// Maximum gap between keys used during the fuzzing tests: the \`_prepareKeys\` function with make sure that +// Maximum gap between keys used during the fuzzing tests: the \`_prepareKeys\` function will make sure that // key#n+1 is in the [key#n, key#n + _KEY_MAX_GAP] range. uint8 internal constant _KEY_MAX_GAP = 64; @@ -36,7 +36,7 @@ function _prepareKeys(${opts.keyTypeName}[] memory keys, ${opts.keyTypeName} max } } -function _assertLatestCheckpoint(bool exist, ${opts.keyTypeName} key, ${opts.valueTypeName} value) internal { +function _assertLatestCheckpoint(bool exist, ${opts.keyTypeName} key, ${opts.valueTypeName} value) internal view { (bool _exist, ${opts.keyTypeName} _key, ${opts.valueTypeName} _value) = _ckpts.latestCheckpoint(); assertEq(_exist, exist); assertEq(_key, key); diff --git a/scripts/generate/templates/EnumerableMap.js b/scripts/generate/templates/EnumerableMap.js index c9cad6c1b..284e5ac02 100644 --- a/scripts/generate/templates/EnumerableMap.js +++ b/scripts/generate/templates/EnumerableMap.js @@ -17,6 +17,7 @@ import {EnumerableSet} from "./EnumerableSet.sol"; * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. + * - Map can be cleared (all entries removed) in O(n). * * \`\`\`solidity * contract Example { @@ -91,6 +92,20 @@ function remove(Bytes32ToBytes32Map storage map, bytes32 key) internal returns ( return map._keys.remove(key); } +/** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ +function clear(Bytes32ToBytes32Map storage map) internal { + uint256 len = length(map); + for (uint256 i = 0; i < len; ++i) { + delete map._values[map._keys.at(i)]; + } + map._keys.clear(); +} + /** * @dev Returns true if the key is in the map. O(1). */ @@ -188,6 +203,16 @@ function remove(${name} storage map, ${keyType} key) internal returns (bool) { return remove(map._inner, ${toBytes32(keyType, 'key')}); } +/** + * @dev Removes all the entries from a map. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the map grows to the point where clearing it consumes too much gas to fit in a block. + */ +function clear(${name} storage map) internal { + clear(map._inner); +} + /** * @dev Returns true if the key is in the map. O(1). */ diff --git a/scripts/generate/templates/EnumerableSet.js b/scripts/generate/templates/EnumerableSet.js index 02eccd0df..3169d6a46 100644 --- a/scripts/generate/templates/EnumerableSet.js +++ b/scripts/generate/templates/EnumerableSet.js @@ -5,6 +5,8 @@ const { TYPES } = require('./EnumerableSet.opts'); const header = `\ pragma solidity ^0.8.20; +import {Arrays} from "../Arrays.sol"; + /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive @@ -15,6 +17,7 @@ pragma solidity ^0.8.20; * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. + * - Set can be cleared (all elements removed) in O(n). * * \`\`\`solidity * contract Example { @@ -117,6 +120,20 @@ function _remove(Set storage set, bytes32 value) private returns (bool) { } } +/** + * @dev Removes all the values from a set. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + */ +function _clear(Set storage set) private { + uint256 len = _length(set); + for (uint256 i = 0; i < len; ++i) { + delete set._positions[set._values[i]]; + } + Arrays.unsafeSetLength(set._values, 0); +} + /** * @dev Returns true if the value is in the set. O(1). */ @@ -185,6 +202,16 @@ function remove(${name} storage set, ${type} value) internal returns (bool) { return _remove(set._inner, ${toBytes32(type, 'value')}); } +/** + * @dev Removes all the values from a set. O(n). + * + * WARNING: Developers should keep in mind that this function has an unbounded cost and using it may render the + * function uncallable if the set grows to the point where clearing it consumes too much gas to fit in a block. + */ +function clear(${name} storage set) internal { + _clear(set._inner); +} + /** * @dev Returns true if the value is in the set. O(1). */ diff --git a/scripts/generate/templates/SlotDerivation.js b/scripts/generate/templates/SlotDerivation.js index ec4d244b9..a00e98167 100644 --- a/scripts/generate/templates/SlotDerivation.js +++ b/scripts/generate/templates/SlotDerivation.js @@ -20,7 +20,7 @@ pragma solidity ^0.8.20; * using SlotDerivation for bytes32; * * // Declare a namespace - * string private constant _NAMESPACE = "" // eg. OpenZeppelin.Slot + * string private constant _NAMESPACE = ""; // eg. OpenZeppelin.Slot * * function setValueInNamespace(uint256 key, address newValue) internal { * _NAMESPACE.erc7201Slot().deriveMapping(key).getAddressSlot().value = newValue; diff --git a/scripts/generate/templates/SlotDerivation.t.js b/scripts/generate/templates/SlotDerivation.t.js index f03e1fc25..824af079a 100644 --- a/scripts/generate/templates/SlotDerivation.t.js +++ b/scripts/generate/templates/SlotDerivation.t.js @@ -45,7 +45,7 @@ function _assertDeriveArray(uint256 length, uint256 offset) public { const mapping = ({ type, name }) => `\ mapping(${type} => bytes) private _${type}Mapping; -function testSymbolicDeriveMapping${name}(${type} key) public { +function testSymbolicDeriveMapping${name}(${type} key) public view { bytes32 baseSlot; assembly { baseSlot := _${type}Mapping.slot @@ -76,15 +76,15 @@ function testSymbolicDeriveMapping${name}Dirty(bytes32 dirtyKey) public { const boundedMapping = ({ type, name }) => `\ mapping(${type} => bytes) private _${type}Mapping; -function testDeriveMapping${name}(${type} memory key) public { +function testDeriveMapping${name}(${type} memory key) public view { _assertDeriveMapping${name}(key); } -function symbolicDeriveMapping${name}() public { +function symbolicDeriveMapping${name}() public view { _assertDeriveMapping${name}(svm.create${name}(256, "DeriveMapping${name}Input")); } -function _assertDeriveMapping${name}(${type} memory key) internal { +function _assertDeriveMapping${name}(${type} memory key) internal view { bytes32 baseSlot; assembly { baseSlot := _${type}Mapping.slot diff --git a/scripts/generate/templates/TransientSlot.js b/scripts/generate/templates/TransientSlot.js index 8e291bc13..9ede32f85 100644 --- a/scripts/generate/templates/TransientSlot.js +++ b/scripts/generate/templates/TransientSlot.js @@ -34,7 +34,7 @@ pragma solidity ^0.8.24; const udvt = ({ type, name }) => `\ /** - * @dev UDVT that represent a slot holding a ${type}. + * @dev UDVT that represents a slot holding ${type == 'address' ? 'an' : 'a'} ${type}. */ type ${name}Slot is bytes32; diff --git a/scripts/prepare-docs.sh b/scripts/prepare-docs.sh index d1317b092..0ff5b94dc 100755 --- a/scripts/prepare-docs.sh +++ b/scripts/prepare-docs.sh @@ -18,7 +18,7 @@ examples_source_dir="contracts/mocks/docs" examples_target_dir="docs/modules/api/examples" for f in "$examples_source_dir"/**/*.sol; do - name="${f/#"$examples_source_dir/"/}" + name="${f/#"$examples_source_dir"/}" mkdir -p "$examples_target_dir/$(dirname "$name")" sed -Ee '/^import/s|"(\.\./)+|"@openzeppelin/contracts/|' "$f" > "$examples_target_dir/$name" done diff --git a/scripts/prepare.sh b/scripts/prepare.sh deleted file mode 100755 index a7d74227d..000000000 --- a/scripts/prepare.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/usr/bin/env bash - -set -euo pipefail - -if git status &>/dev/null; then git config core.hooksPath .githooks; fi diff --git a/scripts/release/format-changelog.js b/scripts/release/format-changelog.js index b8bcc8c71..c96dc924a 100755 --- a/scripts/release/format-changelog.js +++ b/scripts/release/format-changelog.js @@ -27,7 +27,7 @@ const formatted = changelog .replace(RELEASE_LINE_REGEX, (_, pr, entry) => (pr ? `- ${entry} (${pr})` : `- ${entry}`)) // Add date to new version .replace(VERSION_TITLE_REGEX, `\n## $1 (${new Date().toISOString().split('T')[0]})`) - // Conditionally allow vX.Y.Z.rc-.W sections only in prerelease + // Conditionally allow vX.Y.Z-rc.W sections only in prerelease .replace(/^## \d\.\d\.\d-rc\S+[^]+?(?=^#)/gm, section => (isPrerelease ? section : '')); fs.writeFileSync('CHANGELOG.md', formatted); diff --git a/scripts/set-max-old-space-size.sh b/scripts/set-max-old-space-size.sh new file mode 100755 index 000000000..f56b11dc3 --- /dev/null +++ b/scripts/set-max-old-space-size.sh @@ -0,0 +1,10 @@ +#!/usr/bin/env sh + +# This script sets the node `--max-old-space-size` to 8192 if it is not set already. +# All existing `NODE_OPTIONS` are retained as is. + +export NODE_OPTIONS="${NODE_OPTIONS:-}" + +if [ "${NODE_OPTIONS##*--max-old-space-size*}" = "$NODE_OPTIONS" ]; then + export NODE_OPTIONS="${NODE_OPTIONS} --max-old-space-size=8192" +fi diff --git a/scripts/solhint-custom/package.json b/scripts/solhint-custom/package.json index 075eb929d..ce9690d74 100644 --- a/scripts/solhint-custom/package.json +++ b/scripts/solhint-custom/package.json @@ -1,5 +1,8 @@ { "name": "solhint-plugin-openzeppelin", "version": "0.0.0", - "private": true + "private": true, + "dependencies": { + "minimatch": "^3.1.2" + } } diff --git a/scripts/upgradeable/upgradeable.patch b/scripts/upgradeable/upgradeable.patch index 458ecd435..5d54ef420 100644 --- a/scripts/upgradeable/upgradeable.patch +++ b/scripts/upgradeable/upgradeable.patch @@ -59,7 +59,7 @@ index ff596b0c3..000000000 - - diff --git a/README.md b/README.md -index fa7b4e31e..4799b6376 100644 +index 60d0a430a..0e4f91a6d 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,9 @@ @@ -110,7 +110,7 @@ index fa7b4e31e..4799b6376 100644 } ``` diff --git a/contracts/package.json b/contracts/package.json -index 845e8c403..8dc181b91 100644 +index 3682eadeb..4f870d094 100644 --- a/contracts/package.json +++ b/contracts/package.json @@ -1,5 +1,5 @@ @@ -118,7 +118,7 @@ index 845e8c403..8dc181b91 100644 - "name": "@openzeppelin/contracts", + "name": "@openzeppelin/contracts-upgradeable", "description": "Secure Smart Contract library for Solidity", - "version": "5.0.2", + "version": "5.2.0", "files": [ @@ -13,7 +13,7 @@ }, @@ -140,7 +140,7 @@ index 845e8c403..8dc181b91 100644 + } } diff --git a/contracts/utils/cryptography/EIP712.sol b/contracts/utils/cryptography/EIP712.sol -index 77c4c8990..602467f40 100644 +index bcb67c87a..7195c3bbd 100644 --- a/contracts/utils/cryptography/EIP712.sol +++ b/contracts/utils/cryptography/EIP712.sol @@ -4,7 +4,6 @@ @@ -151,7 +151,7 @@ index 77c4c8990..602467f40 100644 import {IERC5267} from "../../interfaces/IERC5267.sol"; /** -@@ -28,28 +27,18 @@ import {IERC5267} from "../../interfaces/IERC5267.sol"; +@@ -28,30 +27,18 @@ import {IERC5267} from "../../interfaces/IERC5267.sol"; * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain * separator of the implementation contract. This will cause the {_domainSeparatorV4} function to always rebuild the * separator from the immutable values, which is cheaper than accessing a cached version in cold storage. @@ -177,14 +177,16 @@ index 77c4c8990..602467f40 100644 - ShortString private immutable _name; - ShortString private immutable _version; +- // slither-disable-next-line constable-states - string private _nameFallback; +- // slither-disable-next-line constable-states - string private _versionFallback; + string private _name; + string private _version; /** * @dev Initializes the domain separator and parameter caches. -@@ -64,29 +53,23 @@ abstract contract EIP712 is IERC5267 { +@@ -66,29 +53,23 @@ abstract contract EIP712 is IERC5267 { * contract upgrade]. */ constructor(string memory name, string memory version) { @@ -222,7 +224,7 @@ index 77c4c8990..602467f40 100644 } /** -@@ -125,6 +108,10 @@ abstract contract EIP712 is IERC5267 { +@@ -127,6 +108,10 @@ abstract contract EIP712 is IERC5267 { uint256[] memory extensions ) { @@ -233,7 +235,7 @@ index 77c4c8990..602467f40 100644 return ( hex"0f", // 01111 _EIP712Name(), -@@ -139,22 +126,62 @@ abstract contract EIP712 is IERC5267 { +@@ -141,22 +126,62 @@ abstract contract EIP712 is IERC5267 { /** * @dev The name parameter for the EIP712 domain. * @@ -307,10 +309,10 @@ index 77c4c8990..602467f40 100644 } } diff --git a/package.json b/package.json -index c4b358e10..96ab2559c 100644 +index f9e7d9205..c35020d51 100644 --- a/package.json +++ b/package.json -@@ -32,7 +32,7 @@ +@@ -34,7 +34,7 @@ }, "repository": { "type": "git", diff --git a/slither.config.json b/slither.config.json index fa52f4dd1..47892af07 100644 --- a/slither.config.json +++ b/slither.config.json @@ -1,5 +1,4 @@ { "detectors_to_run": "arbitrary-send-erc20,array-by-reference,incorrect-shift,name-reused,rtlo,suicidal,uninitialized-state,uninitialized-storage,arbitrary-send-erc20-permit,controlled-array-length,controlled-delegatecall,delegatecall-loop,msg-value-loop,reentrancy-eth,unchecked-transfer,weak-prng,domain-separator-collision,erc20-interface,erc721-interface,locked-ether,mapping-deletion,shadowing-abstract,tautology,write-after-write,boolean-cst,reentrancy-no-eth,reused-constructor,tx-origin,unchecked-lowlevel,unchecked-send,variable-scope,void-cst,events-access,events-maths,incorrect-unary,boolean-equal,cyclomatic-complexity,deprecated-standards,erc20-indexed,function-init-state,pragma,unused-state,reentrancy-unlimited-gas,constable-states,immutable-states,var-read-using-this", - "filter_paths": "contracts/mocks,contracts/vendor,contracts-exposed", - "compile_force_framework": "hardhat" + "filter_paths": "contracts/mocks,contracts/vendor,contracts-exposed" } diff --git a/solhint.config.js b/solhint.config.js index f0bd7994f..47c1cebfe 100644 --- a/solhint.config.js +++ b/solhint.config.js @@ -1,4 +1,4 @@ -const customRules = require('./scripts/solhint-custom'); +const customRules = require('solhint-plugin-openzeppelin'); const rules = [ 'avoid-tx-origin', diff --git a/test/TESTING.md b/test/TESTING.md index a5ee9323f..321c7e592 100644 --- a/test/TESTING.md +++ b/test/TESTING.md @@ -1,3 +1,3 @@ ## Testing -Unit test are critical to OpenZeppelin Contracts. They help ensure code quality and mitigate against security vulnerabilities. The directory structure within the `/test` directory corresponds to the `/contracts` directory. +Unit tests are critical to OpenZeppelin Contracts. They help ensure code quality and mitigate against security vulnerabilities. The directory structure within the `/test` directory corresponds to the `/contracts` directory. diff --git a/test/access/AccessControl.behavior.js b/test/access/AccessControl.behavior.js index b7ae2a950..c596e6a2e 100644 --- a/test/access/AccessControl.behavior.js +++ b/test/access/AccessControl.behavior.js @@ -21,7 +21,7 @@ function shouldBehaveLikeAccessControl() { expect(await this.mock.hasRole(DEFAULT_ADMIN_ROLE, this.defaultAdmin)).to.be.true; }); - it("other roles's admin is the default admin role", async function () { + it("other role's admin is the default admin role", async function () { expect(await this.mock.getRoleAdmin(ROLE)).to.equal(DEFAULT_ADMIN_ROLE); }); diff --git a/test/access/manager/AuthorityUtils.test.js b/test/access/manager/AuthorityUtils.test.js index 905913f14..465f617ad 100644 --- a/test/access/manager/AuthorityUtils.test.js +++ b/test/access/manager/AuthorityUtils.test.js @@ -2,6 +2,8 @@ const { ethers } = require('hardhat'); const { expect } = require('chai'); const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); +const { MAX_UINT32, MAX_UINT64 } = require('../../helpers/constants'); + async function fixture() { const [user, other] = await ethers.getSigners(); @@ -70,7 +72,7 @@ describe('AuthorityUtils', function () { }); for (const immediate of [true, false]) { - for (const delay of [0n, 42n]) { + for (const delay of [0n, 42n, MAX_UINT32]) { it(`returns (immediate=${immediate}, delay=${delay})`, async function () { await this.authority._setImmediate(immediate); await this.authority._setDelay(delay); @@ -80,6 +82,14 @@ describe('AuthorityUtils', function () { }); } } + + it('out of bound delay', async function () { + await this.authority._setImmediate(false); + await this.authority._setDelay(MAX_UINT64); // bigger than the expected uint32 + const result = await this.mock.$canCallWithDelay(this.authority, this.user, this.other, '0x12345678'); + expect(result.immediate).to.equal(false); + expect(result.delay).to.equal(0n); + }); }); describe('when authority replies with empty data', function () { diff --git a/test/account/utils/draft-ERC4337Utils.test.js b/test/account/utils/draft-ERC4337Utils.test.js index 7c292910d..ab4f345d2 100644 --- a/test/account/utils/draft-ERC4337Utils.test.js +++ b/test/account/utils/draft-ERC4337Utils.test.js @@ -1,19 +1,18 @@ -const { ethers } = require('hardhat'); +const { ethers, entrypoint } = require('hardhat'); const { expect } = require('chai'); const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); const { packValidationData, UserOperation } = require('../../helpers/erc4337'); -const { deployEntrypoint } = require('../../helpers/erc4337-entrypoint'); const { MAX_UINT48 } = require('../../helpers/constants'); const ADDRESS_ONE = '0x0000000000000000000000000000000000000001'; const fixture = async () => { - const { entrypoint } = await deployEntrypoint(); const [authorizer, sender, factory, paymaster] = await ethers.getSigners(); const utils = await ethers.deployContract('$ERC4337Utils'); const SIG_VALIDATION_SUCCESS = await utils.$SIG_VALIDATION_SUCCESS(); const SIG_VALIDATION_FAILED = await utils.$SIG_VALIDATION_FAILED(); - return { utils, authorizer, sender, entrypoint, factory, paymaster, SIG_VALIDATION_SUCCESS, SIG_VALIDATION_FAILED }; + + return { utils, authorizer, sender, factory, paymaster, SIG_VALIDATION_SUCCESS, SIG_VALIDATION_FAILED }; }; describe('ERC4337Utils', function () { @@ -21,6 +20,16 @@ describe('ERC4337Utils', function () { Object.assign(this, await loadFixture(fixture)); }); + describe('entrypoint', function () { + it('v0.7.0', async function () { + await expect(this.utils.$ENTRYPOINT_V07()).to.eventually.equal(entrypoint.v07); + }); + + it('v0.8.0', async function () { + await expect(this.utils.$ENTRYPOINT_V08()).to.eventually.equal(entrypoint.v08); + }); + }); + describe('parseValidationData', function () { it('parses the validation data', async function () { const authorizer = this.authorizer; @@ -28,7 +37,7 @@ describe('ERC4337Utils', function () { const validAfter = 0x9abcdef0n; const validationData = packValidationData(validAfter, validUntil, authorizer); - expect(this.utils.$parseValidationData(validationData)).to.eventually.deep.equal([ + await expect(this.utils.$parseValidationData(validationData)).to.eventually.deep.equal([ authorizer.address, validAfter, validUntil, @@ -40,7 +49,7 @@ describe('ERC4337Utils', function () { const validAfter = 0x12345678n; const validationData = packValidationData(validAfter, 0, authorizer); - expect(this.utils.$parseValidationData(validationData)).to.eventually.deep.equal([ + await expect(this.utils.$parseValidationData(validationData)).to.eventually.deep.equal([ authorizer.address, validAfter, MAX_UINT48, @@ -48,13 +57,13 @@ describe('ERC4337Utils', function () { }); it('parse canonical values', async function () { - expect(this.utils.$parseValidationData(this.SIG_VALIDATION_SUCCESS)).to.eventually.deep.equal([ + await expect(this.utils.$parseValidationData(this.SIG_VALIDATION_SUCCESS)).to.eventually.deep.equal([ ethers.ZeroAddress, 0n, MAX_UINT48, ]); - expect(this.utils.$parseValidationData(this.SIG_VALIDATION_FAILED)).to.eventually.deep.equal([ + await expect(this.utils.$parseValidationData(this.SIG_VALIDATION_FAILED)).to.eventually.deep.equal([ ADDRESS_ONE, 0n, MAX_UINT48, @@ -69,7 +78,7 @@ describe('ERC4337Utils', function () { const validAfter = 0x9abcdef0n; const validationData = packValidationData(validAfter, validUntil, authorizer); - expect( + await expect( this.utils.$packValidationData(ethers.Typed.address(authorizer), validAfter, validUntil), ).to.eventually.equal(validationData); }); @@ -80,22 +89,22 @@ describe('ERC4337Utils', function () { const validAfter = 0x9abcdef0n; const validationData = packValidationData(validAfter, validUntil, false); - expect(this.utils.$packValidationData(ethers.Typed.bool(success), validAfter, validUntil)).to.eventually.equal( - validationData, - ); + await expect( + this.utils.$packValidationData(ethers.Typed.bool(success), validAfter, validUntil), + ).to.eventually.equal(validationData); }); it('packing reproduced canonical values', async function () { - expect(this.utils.$packValidationData(ethers.Typed.address(ethers.ZeroAddress), 0n, 0n)).to.eventually.equal( + await expect( + this.utils.$packValidationData(ethers.Typed.address(ethers.ZeroAddress), 0n, 0n), + ).to.eventually.equal(this.SIG_VALIDATION_SUCCESS); + await expect(this.utils.$packValidationData(ethers.Typed.bool(true), 0n, 0n)).to.eventually.equal( this.SIG_VALIDATION_SUCCESS, ); - expect(this.utils.$packValidationData(ethers.Typed.bool(true), 0n, 0n)).to.eventually.equal( - this.SIG_VALIDATION_SUCCESS, - ); - expect(this.utils.$packValidationData(ethers.Typed.address(ADDRESS_ONE), 0n, 0n)).to.eventually.equal( + await expect(this.utils.$packValidationData(ethers.Typed.address(ADDRESS_ONE), 0n, 0n)).to.eventually.equal( this.SIG_VALIDATION_FAILED, ); - expect(this.utils.$packValidationData(ethers.Typed.bool(false), 0n, 0n)).to.eventually.equal( + await expect(this.utils.$packValidationData(ethers.Typed.bool(false), 0n, 0n)).to.eventually.equal( this.SIG_VALIDATION_FAILED, ); }); @@ -113,8 +122,8 @@ describe('ERC4337Utils', function () { const expected = packValidationData(validAfter2, validUntil1, true); // check symmetry - expect(this.utils.$combineValidationData(validationData1, validationData2)).to.eventually.equal(expected); - expect(this.utils.$combineValidationData(validationData2, validationData1)).to.eventually.equal(expected); + await expect(this.utils.$combineValidationData(validationData1, validationData2)).to.eventually.equal(expected); + await expect(this.utils.$combineValidationData(validationData2, validationData1)).to.eventually.equal(expected); }); for (const [authorizer1, authorizer2] of [ @@ -127,8 +136,8 @@ describe('ERC4337Utils', function () { const expected = packValidationData(validAfter2, validUntil1, false); // check symmetry - expect(this.utils.$combineValidationData(validationData1, validationData2)).to.eventually.equal(expected); - expect(this.utils.$combineValidationData(validationData2, validationData1)).to.eventually.equal(expected); + await expect(this.utils.$combineValidationData(validationData1, validationData2)).to.eventually.equal(expected); + await expect(this.utils.$combineValidationData(validationData2, validationData1)).to.eventually.equal(expected); }); } }); @@ -140,7 +149,7 @@ describe('ERC4337Utils', function () { const validUntil = MAX_UINT48; const validationData = packValidationData(validAfter, validUntil, aggregator); - expect(this.utils.$getValidationData(validationData)).to.eventually.deep.equal([aggregator.address, false]); + await expect(this.utils.$getValidationData(validationData)).to.eventually.deep.equal([aggregator.address, false]); }); it('returns the validation data with invalid validity range (expired)', async function () { @@ -149,7 +158,7 @@ describe('ERC4337Utils', function () { const validUntil = 1; const validationData = packValidationData(validAfter, validUntil, aggregator); - expect(this.utils.$getValidationData(validationData)).to.eventually.deep.equal([aggregator.address, true]); + await expect(this.utils.$getValidationData(validationData)).to.eventually.deep.equal([aggregator.address, true]); }); it('returns the validation data with invalid validity range (not yet valid)', async function () { @@ -158,31 +167,23 @@ describe('ERC4337Utils', function () { const validUntil = MAX_UINT48; const validationData = packValidationData(validAfter, validUntil, aggregator); - expect(this.utils.$getValidationData(validationData)).to.eventually.deep.equal([aggregator.address, true]); + await expect(this.utils.$getValidationData(validationData)).to.eventually.deep.equal([aggregator.address, true]); }); - it('returns address(0) and false for validationData = 0', function () { - expect(this.utils.$getValidationData(0n)).to.eventually.deep.equal([ethers.ZeroAddress, false]); + it('returns address(0) and false for validationData = 0', async function () { + await expect(this.utils.$getValidationData(0n)).to.eventually.deep.equal([ethers.ZeroAddress, false]); }); }); describe('hash', function () { - it('returns the operation hash with specified entrypoint and chainId', async function () { - const userOp = new UserOperation({ sender: this.sender, nonce: 1 }); - const chainId = await ethers.provider.getNetwork().then(({ chainId }) => chainId); - const otherChainId = 0xdeadbeef; + for (const [version, instance] of Object.entries(entrypoint)) { + it(`returns the operation hash for entrypoint ${version}`, async function () { + const userOp = new UserOperation({ sender: this.sender, nonce: 1 }); + const expected = await userOp.hash(instance); - // check that helper matches entrypoint logic - expect(this.entrypoint.getUserOpHash(userOp.packed)).to.eventually.equal(userOp.hash(this.entrypoint, chainId)); - - // check library against helper - expect(this.utils.$hash(userOp.packed, this.entrypoint, chainId)).to.eventually.equal( - userOp.hash(this.entrypoint, chainId), - ); - expect(this.utils.$hash(userOp.packed, this.entrypoint, otherChainId)).to.eventually.equal( - userOp.hash(this.entrypoint, otherChainId), - ); - }); + await expect(this.utils.$hash(userOp.packed, instance)).to.eventually.equal(expected); + }); + } }); describe('userOp values', function () { @@ -203,34 +204,34 @@ describe('ERC4337Utils', function () { }); it('returns factory', async function () { - expect(this.utils.$factory(this.userOp.packed)).to.eventually.equal(this.factory); - expect(this.utils.$factory(this.emptyUserOp.packed)).to.eventually.equal(ethers.ZeroAddress); + await expect(this.utils.$factory(this.userOp.packed)).to.eventually.equal(this.factory); + await expect(this.utils.$factory(this.emptyUserOp.packed)).to.eventually.equal(ethers.ZeroAddress); }); it('returns factoryData', async function () { - expect(this.utils.$factoryData(this.userOp.packed)).to.eventually.equal('0x123456'); - expect(this.utils.$factoryData(this.emptyUserOp.packed)).to.eventually.equal('0x'); + await expect(this.utils.$factoryData(this.userOp.packed)).to.eventually.equal('0x123456'); + await expect(this.utils.$factoryData(this.emptyUserOp.packed)).to.eventually.equal('0x'); }); }); it('returns verificationGasLimit', async function () { const userOp = new UserOperation({ sender: this.sender, nonce: 1, verificationGas: 0x12345678n }); - expect(this.utils.$verificationGasLimit(userOp.packed)).to.eventually.equal(userOp.verificationGas); + await expect(this.utils.$verificationGasLimit(userOp.packed)).to.eventually.equal(userOp.verificationGas); }); it('returns callGasLimit', async function () { const userOp = new UserOperation({ sender: this.sender, nonce: 1, callGas: 0x12345678n }); - expect(this.utils.$callGasLimit(userOp.packed)).to.eventually.equal(userOp.callGas); + await expect(this.utils.$callGasLimit(userOp.packed)).to.eventually.equal(userOp.callGas); }); it('returns maxPriorityFeePerGas', async function () { const userOp = new UserOperation({ sender: this.sender, nonce: 1, maxPriorityFee: 0x12345678n }); - expect(this.utils.$maxPriorityFeePerGas(userOp.packed)).to.eventually.equal(userOp.maxPriorityFee); + await expect(this.utils.$maxPriorityFeePerGas(userOp.packed)).to.eventually.equal(userOp.maxPriorityFee); }); it('returns maxFeePerGas', async function () { const userOp = new UserOperation({ sender: this.sender, nonce: 1, maxFeePerGas: 0x12345678n }); - expect(this.utils.$maxFeePerGas(userOp.packed)).to.eventually.equal(userOp.maxFeePerGas); + await expect(this.utils.$maxFeePerGas(userOp.packed)).to.eventually.equal(userOp.maxFeePerGas); }); it('returns gasPrice', async function () { @@ -240,7 +241,7 @@ describe('ERC4337Utils', function () { maxPriorityFee: 0x12345678n, maxFeePerGas: 0x87654321n, }); - expect(this.utils.$gasPrice(userOp.packed)).to.eventually.equal(userOp.maxPriorityFee); + await expect(this.utils.$gasPrice(userOp.packed)).to.eventually.equal(userOp.maxPriorityFee); }); describe('paymasterAndData', function () { @@ -261,27 +262,27 @@ describe('ERC4337Utils', function () { }); it('returns paymaster', async function () { - expect(this.utils.$paymaster(this.userOp.packed)).to.eventually.equal(this.userOp.paymaster); - expect(this.utils.$paymaster(this.emptyUserOp.packed)).to.eventually.equal(ethers.ZeroAddress); + await expect(this.utils.$paymaster(this.userOp.packed)).to.eventually.equal(this.userOp.paymaster); + await expect(this.utils.$paymaster(this.emptyUserOp.packed)).to.eventually.equal(ethers.ZeroAddress); }); it('returns verificationGasLimit', async function () { - expect(this.utils.$paymasterVerificationGasLimit(this.userOp.packed)).to.eventually.equal( + await expect(this.utils.$paymasterVerificationGasLimit(this.userOp.packed)).to.eventually.equal( this.userOp.paymasterVerificationGasLimit, ); - expect(this.utils.$paymasterVerificationGasLimit(this.emptyUserOp.packed)).to.eventually.equal(0n); + await expect(this.utils.$paymasterVerificationGasLimit(this.emptyUserOp.packed)).to.eventually.equal(0n); }); it('returns postOpGasLimit', async function () { - expect(this.utils.$paymasterPostOpGasLimit(this.userOp.packed)).to.eventually.equal( + await expect(this.utils.$paymasterPostOpGasLimit(this.userOp.packed)).to.eventually.equal( this.userOp.paymasterPostOpGasLimit, ); - expect(this.utils.$paymasterPostOpGasLimit(this.emptyUserOp.packed)).to.eventually.equal(0n); + await expect(this.utils.$paymasterPostOpGasLimit(this.emptyUserOp.packed)).to.eventually.equal(0n); }); it('returns data', async function () { - expect(this.utils.$paymasterData(this.userOp.packed)).to.eventually.equal(this.userOp.paymasterData); - expect(this.utils.$paymasterData(this.emptyUserOp.packed)).to.eventually.equal('0x'); + await expect(this.utils.$paymasterData(this.userOp.packed)).to.eventually.equal(this.userOp.paymasterData); + await expect(this.utils.$paymasterData(this.emptyUserOp.packed)).to.eventually.equal('0x'); }); }); }); diff --git a/test/account/utils/draft-ERC7579Utils.t.sol b/test/account/utils/draft-ERC7579Utils.t.sol index fdd4edf59..bc69e4c34 100644 --- a/test/account/utils/draft-ERC7579Utils.t.sol +++ b/test/account/utils/draft-ERC7579Utils.t.sol @@ -20,8 +20,6 @@ contract SampleAccount is IAccount, Ownable { using ERC4337Utils for *; using ERC7579Utils for *; - IEntryPoint internal constant ENTRY_POINT = IEntryPoint(payable(0x0000000071727De22E5E9d8BAf0edAc6f37da032)); - event Log(bool duringValidation, Execution[] calls); error UnsupportedCallType(CallType callType); @@ -33,7 +31,7 @@ contract SampleAccount is IAccount, Ownable { bytes32 userOpHash, uint256 missingAccountFunds ) external override returns (uint256 validationData) { - require(msg.sender == address(ENTRY_POINT), "only from EP"); + require(msg.sender == address(ERC4337Utils.ENTRYPOINT_V07), "only from EP"); // Check signature if (userOpHash.toEthSignedMessageHash().recover(userOp.signature) != owner()) { revert OwnableUnauthorizedAccount(_msgSender()); @@ -66,7 +64,7 @@ contract SampleAccount is IAccount, Ownable { // builtin decoder for the `execute` function. // This is where the vulnerability from ExecutionLib results in a different result between validation - // andexecution. + // and execution. emit Log(true, executionCalldata.decodeBatch()); } @@ -81,7 +79,7 @@ contract SampleAccount is IAccount, Ownable { } function execute(Mode mode, bytes calldata executionCalldata) external payable { - require(msg.sender == address(this) || msg.sender == address(ENTRY_POINT), "not auth"); + require(msg.sender == address(this) || msg.sender == address(ERC4337Utils.ENTRYPOINT_V07), "not auth"); (CallType callType, ExecType execType, , ) = mode.decodeMode(); @@ -105,7 +103,6 @@ contract ERC7579UtilsTest is Test { using ERC4337Utils for *; using ERC7579Utils for *; - IEntryPoint private constant ENTRYPOINT = IEntryPoint(payable(0x0000000071727De22E5E9d8BAf0edAc6f37da032)); address private _owner; uint256 private _ownerKey; address private _account; @@ -166,7 +163,7 @@ contract ERC7579UtilsTest is Test { userOps[0].signature = abi.encodePacked(r, s, v); vm.recordLogs(); - ENTRYPOINT.handleOps(userOps, payable(_beneficiary)); + ERC4337Utils.ENTRYPOINT_V07.handleOps(userOps, payable(_beneficiary)); assertEq(_recipient1.balance, 1 wei); assertEq(_recipient2.balance, 1 wei); @@ -224,7 +221,7 @@ contract ERC7579UtilsTest is Test { abi.encodeWithSelector(ERC7579Utils.ERC7579DecodingError.selector) ) ); - ENTRYPOINT.handleOps(userOps, payable(_beneficiary)); + ERC4337Utils.ENTRYPOINT_V07.handleOps(userOps, payable(_beneficiary)); _collectAndPrintLogs(false); } @@ -282,7 +279,7 @@ contract ERC7579UtilsTest is Test { abi.encodeWithSelector(ERC7579Utils.ERC7579DecodingError.selector) ) ); - ENTRYPOINT.handleOps(userOps, payable(_beneficiary)); + ERC4337Utils.ENTRYPOINT_V07.handleOps(userOps, payable(_beneficiary)); _collectAndPrintLogs(true); } @@ -378,7 +375,7 @@ contract ERC7579UtilsTest is Test { } function hashUserOperation(PackedUserOperation calldata useroperation) public view returns (bytes32) { - return useroperation.hash(address(ENTRYPOINT), block.chainid); + return useroperation.hash(address(ERC4337Utils.ENTRYPOINT_V07)); } function _collectAndPrintLogs(bool includeTotalValue) internal { diff --git a/test/account/utils/draft-ERC7579Utils.test.js b/test/account/utils/draft-ERC7579Utils.test.js index 7419c667b..b0ca86c46 100644 --- a/test/account/utils/draft-ERC7579Utils.test.js +++ b/test/account/utils/draft-ERC7579Utils.test.js @@ -2,13 +2,14 @@ const { ethers } = require('hardhat'); const { expect } = require('chai'); const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); const { + CALL_TYPE_CALL, + CALL_TYPE_BATCH, + CALL_TYPE_DELEGATE, EXEC_TYPE_DEFAULT, EXEC_TYPE_TRY, encodeSingle, encodeBatch, encodeDelegate, - CALL_TYPE_CALL, - CALL_TYPE_BATCH, encodeMode, } = require('../../helpers/erc7579'); const { selector } = require('../../helpers/methods'); @@ -29,6 +30,14 @@ describe('ERC7579Utils', function () { Object.assign(this, await loadFixture(fixture)); }); + it('constants', async function () { + await expect(this.utils.$CALLTYPE_SINGLE()).to.eventually.equal(CALL_TYPE_CALL); + await expect(this.utils.$CALLTYPE_BATCH()).to.eventually.equal(CALL_TYPE_BATCH); + await expect(this.utils.$CALLTYPE_DELEGATECALL()).to.eventually.equal(CALL_TYPE_DELEGATE); + await expect(this.utils.$EXECTYPE_DEFAULT()).to.eventually.equal(EXEC_TYPE_DEFAULT); + await expect(this.utils.$EXECTYPE_TRY()).to.eventually.equal(EXEC_TYPE_TRY); + }); + describe('execSingle', function () { it('calls the target with value', async function () { const value = 0x012; @@ -36,7 +45,7 @@ describe('ERC7579Utils', function () { await expect(this.utils.$execSingle(data, EXEC_TYPE_DEFAULT)).to.emit(this.target, 'MockFunctionCalled'); - expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value); + await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value); }); it('calls the target with value and args', async function () { @@ -51,7 +60,19 @@ describe('ERC7579Utils', function () { .to.emit(this.target, 'MockFunctionCalledWithArgs') .withArgs(42, '0x1234'); - expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value); + await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value); + }); + + it('default to calling self is target is address(0) (ERC-7821 calldata compression)', async function () { + const data = encodeSingle( + ethers.ZeroAddress, // address(0) + 0, + this.utils.interface.encodeFunctionData('$CALLTYPE_SINGLE', []), + ); + + await expect(this.utils.$execSingle(data, EXEC_TYPE_DEFAULT)) + .to.emit(this.utils, 'return$execSingle') + .withArgs([ethers.zeroPadBytes(CALL_TYPE_CALL, 32)]); }); it('reverts when target reverts in default ExecType', async function () { @@ -107,8 +128,8 @@ describe('ERC7579Utils', function () { .to.emit(this.target, 'MockFunctionCalled') .to.emit(this.anotherTarget, 'MockFunctionCalled'); - expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1); - expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(value2); + await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1); + await expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(value2); }); it('calls the targets with value and args', async function () { @@ -127,8 +148,19 @@ describe('ERC7579Utils', function () { .to.emit(this.target, 'MockFunctionCalledWithArgs') .to.emit(this.anotherTarget, 'MockFunctionCalledWithArgs'); - expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1); - expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(value2); + await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1); + await expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(value2); + }); + + it('default to calling self is target is address(0) (ERC-7821 calldata compression)', async function () { + const data = encodeBatch( + [ethers.ZeroAddress, 0, this.utils.interface.encodeFunctionData('$CALLTYPE_SINGLE', [])], + [ethers.ZeroAddress, 0, this.utils.interface.encodeFunctionData('$CALLTYPE_BATCH', [])], + ); + + await expect(this.utils.$execBatch(data, EXEC_TYPE_DEFAULT)) + .to.emit(this.utils, 'return$execBatch') + .withArgs([ethers.zeroPadBytes(CALL_TYPE_CALL, 32), ethers.zeroPadBytes(CALL_TYPE_BATCH, 32)]); }); it('reverts when any target reverts in default ExecType', async function () { @@ -161,8 +193,8 @@ describe('ERC7579Utils', function () { ); // Check balances - expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1); - expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(0); + await expect(ethers.provider.getBalance(this.target)).to.eventually.equal(value1); + await expect(ethers.provider.getBalance(this.anotherTarget)).to.eventually.equal(0); }); it('reverts with an invalid exec type', async function () { @@ -188,9 +220,20 @@ describe('ERC7579Utils', function () { this.target.interface.encodeFunctionData('mockFunctionWritesStorage', [slot, value]), ); - expect(ethers.provider.getStorage(this.utils.target, slot)).to.eventually.equal(ethers.ZeroHash); + await expect(ethers.provider.getStorage(this.utils.target, slot)).to.eventually.equal(ethers.ZeroHash); await this.utils.$execDelegateCall(data, EXEC_TYPE_DEFAULT); - expect(ethers.provider.getStorage(this.utils.target, slot)).to.eventually.equal(value); + await expect(ethers.provider.getStorage(this.utils.target, slot)).to.eventually.equal(value); + }); + + it('default to calling self is target is address(0) (ERC-7821 calldata compression)', async function () { + const data = encodeDelegate( + ethers.ZeroAddress, + this.utils.interface.encodeFunctionData('$CALLTYPE_DELEGATECALL', []), + ); + + await expect(this.utils.$execDelegateCall(data, EXEC_TYPE_DEFAULT)) + .to.emit(this.utils, 'return$execDelegateCall') + .withArgs([ethers.zeroPadBytes(CALL_TYPE_DELEGATE, 32)]); }); it('reverts when target reverts in default ExecType', async function () { @@ -227,7 +270,7 @@ describe('ERC7579Utils', function () { const selector = '0x12345678'; const payload = ethers.toBeHex(0, 22); - expect(this.utils.$encodeMode(callType, execType, selector, payload)).to.eventually.equal( + await expect(this.utils.$encodeMode(callType, execType, selector, payload)).to.eventually.equal( encodeMode({ callType, execType, @@ -243,7 +286,7 @@ describe('ERC7579Utils', function () { const selector = '0x12345678'; const payload = ethers.toBeHex(0, 22); - expect( + await expect( this.utils.$decodeMode( encodeMode({ callType, @@ -260,7 +303,7 @@ describe('ERC7579Utils', function () { const value = 0x123; const data = '0x12345678'; - expect(this.utils.$encodeSingle(target, value, data)).to.eventually.equal(encodeSingle(target, value, data)); + await expect(this.utils.$encodeSingle(target, value, data)).to.eventually.equal(encodeSingle(target, value, data)); }); it('decodes single', async function () { @@ -268,7 +311,7 @@ describe('ERC7579Utils', function () { const value = 0x123; const data = '0x12345678'; - expect(this.utils.$decodeSingle(encodeSingle(target, value, data))).to.eventually.deep.equal([ + await expect(this.utils.$decodeSingle(encodeSingle(target, value, data))).to.eventually.deep.equal([ target.target, value, data, @@ -281,7 +324,7 @@ describe('ERC7579Utils', function () { [this.anotherTarget, 0x456, '0x12345678'], ]; - expect(this.utils.$encodeBatch(entries)).to.eventually.equal(encodeBatch(...entries)); + await expect(this.utils.$encodeBatch(entries)).to.eventually.equal(encodeBatch(...entries)); }); it('decodes batch', async function () { @@ -290,63 +333,66 @@ describe('ERC7579Utils', function () { [this.anotherTarget.target, 0x456, '0x12345678'], ]; - expect(this.utils.$decodeBatch(encodeBatch(...entries))).to.eventually.deep.equal(entries); + await expect(this.utils.$decodeBatch(encodeBatch(...entries))).to.eventually.deep.equal(entries); }); it('encodes delegate', async function () { const target = this.target; const data = '0x12345678'; - expect(this.utils.$encodeDelegate(target, data)).to.eventually.equal(encodeDelegate(target, data)); + await expect(this.utils.$encodeDelegate(target, data)).to.eventually.equal(encodeDelegate(target, data)); }); it('decodes delegate', async function () { const target = this.target; const data = '0x12345678'; - expect(this.utils.$decodeDelegate(encodeDelegate(target, data))).to.eventually.deep.equal([target.target, data]); + await expect(this.utils.$decodeDelegate(encodeDelegate(target, data))).to.eventually.deep.equal([ + target.target, + data, + ]); }); describe('global', function () { describe('eqCallTypeGlobal', function () { it('returns true if both call types are equal', async function () { - expect(this.utilsGlobal.$eqCallTypeGlobal(CALL_TYPE_BATCH, CALL_TYPE_BATCH)).to.eventually.be.true; + await expect(this.utilsGlobal.$eqCallTypeGlobal(CALL_TYPE_BATCH, CALL_TYPE_BATCH)).to.eventually.be.true; }); it('returns false if both call types are different', async function () { - expect(this.utilsGlobal.$eqCallTypeGlobal(CALL_TYPE_CALL, CALL_TYPE_BATCH)).to.eventually.be.false; + await expect(this.utilsGlobal.$eqCallTypeGlobal(CALL_TYPE_CALL, CALL_TYPE_BATCH)).to.eventually.be.false; }); }); describe('eqExecTypeGlobal', function () { it('returns true if both exec types are equal', async function () { - expect(this.utilsGlobal.$eqExecTypeGlobal(EXEC_TYPE_TRY, EXEC_TYPE_TRY)).to.eventually.be.true; + await expect(this.utilsGlobal.$eqExecTypeGlobal(EXEC_TYPE_TRY, EXEC_TYPE_TRY)).to.eventually.be.true; }); it('returns false if both exec types are different', async function () { - expect(this.utilsGlobal.$eqExecTypeGlobal(EXEC_TYPE_DEFAULT, EXEC_TYPE_TRY)).to.eventually.be.false; + await expect(this.utilsGlobal.$eqExecTypeGlobal(EXEC_TYPE_DEFAULT, EXEC_TYPE_TRY)).to.eventually.be.false; }); }); describe('eqModeSelectorGlobal', function () { it('returns true if both selectors are equal', async function () { - expect(this.utilsGlobal.$eqModeSelectorGlobal('0x12345678', '0x12345678')).to.eventually.be.true; + await expect(this.utilsGlobal.$eqModeSelectorGlobal('0x12345678', '0x12345678')).to.eventually.be.true; }); it('returns false if both selectors are different', async function () { - expect(this.utilsGlobal.$eqModeSelectorGlobal('0x12345678', '0x87654321')).to.eventually.be.false; + await expect(this.utilsGlobal.$eqModeSelectorGlobal('0x12345678', '0x87654321')).to.eventually.be.false; }); }); describe('eqModePayloadGlobal', function () { it('returns true if both payloads are equal', async function () { - expect(this.utilsGlobal.$eqModePayloadGlobal(ethers.toBeHex(0, 22), ethers.toBeHex(0, 22))).to.eventually.be - .true; + await expect(this.utilsGlobal.$eqModePayloadGlobal(ethers.toBeHex(0, 22), ethers.toBeHex(0, 22))).to.eventually + .be.true; }); it('returns false if both payloads are different', async function () { - expect(this.utilsGlobal.$eqModePayloadGlobal(ethers.toBeHex(0, 22), ethers.toBeHex(1, 22))).to.eventually.be - .false; + await expect(this.utilsGlobal.$eqModePayloadGlobal(ethers.toBeHex(0, 22), ethers.toBeHex(1, 22))).to.eventually + .be.false; }); }); }); diff --git a/test/bin/EntryPoint080.abi b/test/bin/EntryPoint080.abi new file mode 100644 index 000000000..22fd32c46 --- /dev/null +++ b/test/bin/EntryPoint080.abi @@ -0,0 +1 @@ +[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"bool","name":"success","type":"bool"},{"internalType":"bytes","name":"ret","type":"bytes"}],"name":"DelegateAndRevert","type":"error"},{"inputs":[{"internalType":"uint256","name":"opIndex","type":"uint256"},{"internalType":"string","name":"reason","type":"string"}],"name":"FailedOp","type":"error"},{"inputs":[{"internalType":"uint256","name":"opIndex","type":"uint256"},{"internalType":"string","name":"reason","type":"string"},{"internalType":"bytes","name":"inner","type":"bytes"}],"name":"FailedOpWithRevert","type":"error"},{"inputs":[],"name":"InvalidShortString","type":"error"},{"inputs":[{"internalType":"bytes","name":"returnData","type":"bytes"}],"name":"PostOpReverted","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"SenderAddressResult","type":"error"},{"inputs":[{"internalType":"address","name":"aggregator","type":"address"}],"name":"SignatureValidationFailed","type":"error"},{"inputs":[{"internalType":"string","name":"str","type":"string"}],"name":"StringTooLong","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"address","name":"factory","type":"address"},{"indexed":false,"internalType":"address","name":"paymaster","type":"address"}],"name":"AccountDeployed","type":"event"},{"anonymous":false,"inputs":[],"name":"BeforeExecution","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalDeposit","type":"uint256"}],"name":"Deposited","type":"event"},{"anonymous":false,"inputs":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"revertReason","type":"bytes"}],"name":"PostOpRevertReason","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"aggregator","type":"address"}],"name":"SignatureAggregatorChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"totalStaked","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"unstakeDelaySec","type":"uint256"}],"name":"StakeLocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"withdrawTime","type":"uint256"}],"name":"StakeUnlocked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"withdrawAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"StakeWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"paymaster","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"bool","name":"success","type":"bool"},{"indexed":false,"internalType":"uint256","name":"actualGasCost","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"actualGasUsed","type":"uint256"}],"name":"UserOperationEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"UserOperationPrefundTooLow","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"},{"indexed":false,"internalType":"bytes","name":"revertReason","type":"bytes"}],"name":"UserOperationRevertReason","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"address","name":"withdrawAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[{"internalType":"uint32","name":"unstakeDelaySec","type":"uint32"}],"name":"addStake","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"delegateAndRevert","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"depositTo","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getDepositInfo","outputs":[{"components":[{"internalType":"uint256","name":"deposit","type":"uint256"},{"internalType":"bool","name":"staked","type":"bool"},{"internalType":"uint112","name":"stake","type":"uint112"},{"internalType":"uint32","name":"unstakeDelaySec","type":"uint32"},{"internalType":"uint48","name":"withdrawTime","type":"uint48"}],"internalType":"struct IStakeManager.DepositInfo","name":"info","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeparatorV4","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint192","name":"key","type":"uint192"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPackedUserOpTypeHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"bytes","name":"initCode","type":"bytes"}],"name":"getSenderAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation","name":"userOp","type":"tuple"}],"name":"getUserOpHash","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation[]","name":"userOps","type":"tuple[]"},{"internalType":"contract IAggregator","name":"aggregator","type":"address"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct IEntryPoint.UserOpsPerAggregator[]","name":"opsPerAggregator","type":"tuple[]"},{"internalType":"address payable","name":"beneficiary","type":"address"}],"name":"handleAggregatedOps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"bytes","name":"initCode","type":"bytes"},{"internalType":"bytes","name":"callData","type":"bytes"},{"internalType":"bytes32","name":"accountGasLimits","type":"bytes32"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"bytes32","name":"gasFees","type":"bytes32"},{"internalType":"bytes","name":"paymasterAndData","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"}],"internalType":"struct PackedUserOperation[]","name":"ops","type":"tuple[]"},{"internalType":"address payable","name":"beneficiary","type":"address"}],"name":"handleOps","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint192","name":"key","type":"uint192"}],"name":"incrementNonce","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"callData","type":"bytes"},{"components":[{"components":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"nonce","type":"uint256"},{"internalType":"uint256","name":"verificationGasLimit","type":"uint256"},{"internalType":"uint256","name":"callGasLimit","type":"uint256"},{"internalType":"uint256","name":"paymasterVerificationGasLimit","type":"uint256"},{"internalType":"uint256","name":"paymasterPostOpGasLimit","type":"uint256"},{"internalType":"uint256","name":"preVerificationGas","type":"uint256"},{"internalType":"address","name":"paymaster","type":"address"},{"internalType":"uint256","name":"maxFeePerGas","type":"uint256"},{"internalType":"uint256","name":"maxPriorityFeePerGas","type":"uint256"}],"internalType":"struct EntryPoint.MemoryUserOp","name":"mUserOp","type":"tuple"},{"internalType":"bytes32","name":"userOpHash","type":"bytes32"},{"internalType":"uint256","name":"prefund","type":"uint256"},{"internalType":"uint256","name":"contextOffset","type":"uint256"},{"internalType":"uint256","name":"preOpGas","type":"uint256"}],"internalType":"struct EntryPoint.UserOpInfo","name":"opInfo","type":"tuple"},{"internalType":"bytes","name":"context","type":"bytes"}],"name":"innerHandleOp","outputs":[{"internalType":"uint256","name":"actualGasCost","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint192","name":"","type":"uint192"}],"name":"nonceSequenceNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"senderCreator","outputs":[{"internalType":"contract ISenderCreator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unlockStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"withdrawAddress","type":"address"}],"name":"withdrawStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"withdrawAddress","type":"address"},{"internalType":"uint256","name":"withdrawAmount","type":"uint256"}],"name":"withdrawTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}] \ No newline at end of file diff --git a/test/bin/EntryPoint080.bytecode b/test/bin/EntryPoint080.bytecode new file mode 100644 index 0000000000000000000000000000000000000000..f3f3bd1c1be220e99009e479c79697f0d66d18c8 GIT binary patch literal 21738 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 literal 0 HcmV?d00001 diff --git a/test/bin/SenderCreator080.abi b/test/bin/SenderCreator080.abi new file mode 100644 index 000000000..e169340ac --- /dev/null +++ b/test/bin/SenderCreator080.abi @@ -0,0 +1 @@ +[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256","name":"opIndex","type":"uint256"},{"internalType":"string","name":"reason","type":"string"},{"internalType":"bytes","name":"inner","type":"bytes"}],"name":"FailedOpWithRevert","type":"error"},{"inputs":[{"internalType":"bytes","name":"initCode","type":"bytes"}],"name":"createSender","outputs":[{"internalType":"address","name":"sender","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"entryPoint","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"bytes","name":"initCallData","type":"bytes"}],"name":"initEip7702Sender","outputs":[],"stateMutability":"nonpayable","type":"function"}] \ No newline at end of file diff --git a/test/bin/SenderCreator080.bytecode b/test/bin/SenderCreator080.bytecode new file mode 100644 index 0000000000000000000000000000000000000000..0a8c61fb52987901cf2cbfbb119129d55d2a3c60 GIT binary patch literal 1217 zcmbVL&1(};5Z^I-*psv+ji7}-?CMRi)+BzQwzL%$TarCwOBdXEWK#{qq&D?X6n5Y4 zChaksRuK=Sh$lt#9}rsf;GupTRPZ3wiwE&w@FbYlx7!Z_t*!JO-VAT%&HQHOH)vtE zf?}+xl?u(OZq+qCic4))THU)p7N&cKR4e`bleZkE@Lf&MKY0H+Ooh{d;|U7iRO~ia zwm*Mj&=Pox(c)H~EW$#8U5;K`x3gydC59a~w6yxF?or`|Q;k(nW++0`0~&HuT7?QL zTLv|ShSM9D24)ZGKSyQyZtCva*)w`gigbmkcsQlmNSx#}c*8ZGr%4sGvs4oN^j}mB zUtxEW+id{eB%3Kn7*uuloVkwkA94xX`Olfsw3&HbA80_bNi8Wlie*p`QRc!%gWqOP zPiGhDzm$l_j~yq)Oy0Q2Ca#5};0?ivqmluK@M2C5K6Y#Xl8&>hYnQrQv{Z>$&b zdz8?VG^C}ps#k3+F7%tPRnprD!4jTl*zQ6EA`UpLsUgHZ8pKfS8Rja?S#6TdkW9P! zJ&1FPq%?Ez;_aK82-)zUE7*ggg0f!MTB&$MO=)OwV5anPVy?k&lj<)DiZ-VxL75BA z=TmV~yk5AKGf0}|a%5zzaD(*c$HyiTg=~Ht`?yzq`Js^=9VreSY#~O+#N_=Cl6;g6 kew^>DJ$tkGwE4oqLi>}c#jo|pS1udHLN47aNNqybUt=U#&;S4c literal 0 HcmV?d00001 diff --git a/test/governance/Governor.t.sol b/test/governance/Governor.t.sol index 958461abb..66b684d26 100644 --- a/test/governance/Governor.t.sol +++ b/test/governance/Governor.t.sol @@ -9,7 +9,11 @@ import {Governor} from "@openzeppelin/contracts/governance/Governor.sol"; contract GovernorInternalTest is Test, Governor { constructor() Governor("") {} - function testValidDescriptionForProposer(string memory description, address proposer, bool includeProposer) public { + function testValidDescriptionForProposer( + string memory description, + address proposer, + bool includeProposer + ) public view { if (includeProposer) { description = string.concat(description, "#proposer=", Strings.toHexString(proposer)); } @@ -20,7 +24,7 @@ contract GovernorInternalTest is Test, Governor { string memory description, address commitProposer, address actualProposer - ) public { + ) public view { vm.assume(commitProposer != actualProposer); description = string.concat(description, "#proposer=", Strings.toHexString(commitProposer)); assertFalse(_isValidDescriptionForProposer(actualProposer, description)); diff --git a/test/governance/Governor.test.js b/test/governance/Governor.test.js index 3e48ccfee..0e4283c3b 100644 --- a/test/governance/Governor.test.js +++ b/test/governance/Governor.test.js @@ -96,7 +96,7 @@ describe('Governor', function () { ); }); - shouldSupportInterfaces(['ERC1155Receiver', 'Governor']); + shouldSupportInterfaces(['ERC1155Receiver', 'Governor', 'Governor_5_3']); shouldBehaveLikeERC6372(mode); it('deployment check', async function () { @@ -624,8 +624,8 @@ describe('Governor', function () { await this.helper.connect(this.proposer).propose(); await expect(this.helper.connect(this.owner).cancel('external')) - .to.be.revertedWithCustomError(this.mock, 'GovernorOnlyProposer') - .withArgs(this.owner); + .to.be.revertedWithCustomError(this.mock, 'GovernorUnableToCancel') + .withArgs(this.proposal.id, this.owner); }); it('after vote started', async function () { @@ -633,12 +633,8 @@ describe('Governor', function () { await this.helper.waitForSnapshot(1n); // snapshot + 1 block await expect(this.helper.cancel('external')) - .to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState') - .withArgs( - this.proposal.id, - ProposalState.Active, - GovernorHelper.proposalStatesToBitMap([ProposalState.Pending]), - ); + .to.be.revertedWithCustomError(this.mock, 'GovernorUnableToCancel') + .withArgs(this.proposal.id, this.owner); }); it('after vote', async function () { @@ -647,12 +643,8 @@ describe('Governor', function () { await this.helper.connect(this.voter1).vote({ support: VoteType.For }); await expect(this.helper.cancel('external')) - .to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState') - .withArgs( - this.proposal.id, - ProposalState.Active, - GovernorHelper.proposalStatesToBitMap([ProposalState.Pending]), - ); + .to.be.revertedWithCustomError(this.mock, 'GovernorUnableToCancel') + .withArgs(this.proposal.id, this.voter1); }); it('after deadline', async function () { @@ -662,12 +654,8 @@ describe('Governor', function () { await this.helper.waitForDeadline(); await expect(this.helper.cancel('external')) - .to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState') - .withArgs( - this.proposal.id, - ProposalState.Succeeded, - GovernorHelper.proposalStatesToBitMap([ProposalState.Pending]), - ); + .to.be.revertedWithCustomError(this.mock, 'GovernorUnableToCancel') + .withArgs(this.proposal.id, this.voter1); }); it('after execution', async function () { @@ -678,12 +666,8 @@ describe('Governor', function () { await this.helper.execute(); await expect(this.helper.cancel('external')) - .to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState') - .withArgs( - this.proposal.id, - ProposalState.Executed, - GovernorHelper.proposalStatesToBitMap([ProposalState.Pending]), - ); + .to.be.revertedWithCustomError(this.mock, 'GovernorUnableToCancel') + .withArgs(this.proposal.id, this.voter1); }); }); }); diff --git a/test/governance/extensions/GovernorCountingFractional.test.js b/test/governance/extensions/GovernorCountingFractional.test.js index 393dbad79..a46de210b 100644 --- a/test/governance/extensions/GovernorCountingFractional.test.js +++ b/test/governance/extensions/GovernorCountingFractional.test.js @@ -27,7 +27,7 @@ describe('GovernorCountingFractional', function () { const [owner, proposer, voter1, voter2, voter3, voter4, other] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const mock = await ethers.deployContract('$GovernorFractionalMock', [ name, // name votingDelay, // initialVotingDelay diff --git a/test/governance/extensions/GovernorCountingOverridable.test.js b/test/governance/extensions/GovernorCountingOverridable.test.js index 32ee47439..fd1032b9e 100644 --- a/test/governance/extensions/GovernorCountingOverridable.test.js +++ b/test/governance/extensions/GovernorCountingOverridable.test.js @@ -264,7 +264,7 @@ describe('GovernorCountingOverridable', function () { .to.emit(this.mock, 'OverrideVoteCast') .withArgs(this.voter1, this.helper.id, VoteType.Against, ethers.parseEther('10'), ''); await expect(this.mock.connect(this.voter1).castOverrideVote(this.helper.id, VoteType.Abstain, '')) - .to.be.revertedWithCustomError(this.mock, 'GovernorAlreadyOverridenVote') + .to.be.revertedWithCustomError(this.mock, 'GovernorAlreadyOverriddenVote') .withArgs(this.voter1.address); }); diff --git a/test/governance/extensions/GovernorERC721.test.js b/test/governance/extensions/GovernorERC721.test.js index 1ae5508d7..15910b8fe 100644 --- a/test/governance/extensions/GovernorERC721.test.js +++ b/test/governance/extensions/GovernorERC721.test.js @@ -29,7 +29,7 @@ describe('GovernorERC721', function () { const [owner, voter1, voter2, voter3, voter4] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const mock = await ethers.deployContract('$GovernorMock', [ name, // name votingDelay, // initialVotingDelay diff --git a/test/governance/extensions/GovernorPreventLateQuorum.test.js b/test/governance/extensions/GovernorPreventLateQuorum.test.js index aac0e6898..761087aa9 100644 --- a/test/governance/extensions/GovernorPreventLateQuorum.test.js +++ b/test/governance/extensions/GovernorPreventLateQuorum.test.js @@ -28,7 +28,7 @@ describe('GovernorPreventLateQuorum', function () { const [owner, proposer, voter1, voter2, voter3, voter4] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const mock = await ethers.deployContract('$GovernorPreventLateQuorumMock', [ name, // name votingDelay, // initialVotingDelay diff --git a/test/governance/extensions/GovernorProposalGuardian.test.js b/test/governance/extensions/GovernorProposalGuardian.test.js new file mode 100644 index 000000000..1741072c3 --- /dev/null +++ b/test/governance/extensions/GovernorProposalGuardian.test.js @@ -0,0 +1,132 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +const { impersonate } = require('../../helpers/account'); +const { GovernorHelper } = require('../../helpers/governance'); +const { ProposalState } = require('../../helpers/enums'); + +const TOKENS = [ + { Token: '$ERC20Votes', mode: 'blocknumber' }, + { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' }, +]; +const name = 'Proposal Guardian Governor'; +const version = '1'; +const tokenName = 'MockToken'; +const tokenSymbol = 'MTKN'; +const tokenSupply = ethers.parseEther('100'); +const votingDelay = 4n; +const votingPeriod = 16n; +const value = ethers.parseEther('1'); + +describe('GovernorProposalGuardian', function () { + for (const { Token, mode } of TOKENS) { + const fixture = async () => { + const [owner, proposer, guardian, voter1, voter2, voter3, voter4, other] = await ethers.getSigners(); + const receiver = await ethers.deployContract('CallReceiverMock'); + + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); + const mock = await ethers.deployContract('$GovernorProposalGuardianMock', [ + name, // name + votingDelay, // initialVotingDelay + votingPeriod, // initialVotingPeriod + 0n, // initialProposalThreshold + token, // tokenAddress + 10n, // quorumNumeratorValue + ]); + + await impersonate(mock.target); + await owner.sendTransaction({ to: mock, value }); + await token.$_mint(owner, tokenSupply); + + const helper = new GovernorHelper(mock, mode); + await helper.connect(owner).delegate({ token, to: voter1, value: ethers.parseEther('10') }); + await helper.connect(owner).delegate({ token, to: voter2, value: ethers.parseEther('7') }); + await helper.connect(owner).delegate({ token, to: voter3, value: ethers.parseEther('5') }); + await helper.connect(owner).delegate({ token, to: voter4, value: ethers.parseEther('2') }); + + return { owner, proposer, guardian, voter1, voter2, voter3, voter4, other, receiver, token, mock, helper }; + }; + + describe(`using ${Token}`, function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + + // default proposal + this.proposal = this.helper.setProposal( + [ + { + target: this.receiver.target, + value, + data: this.receiver.interface.encodeFunctionData('mockFunction'), + }, + ], + '', + ); + }); + + it('deployment check', async function () { + await expect(this.mock.name()).to.eventually.equal(name); + await expect(this.mock.token()).to.eventually.equal(this.token); + await expect(this.mock.votingDelay()).to.eventually.equal(votingDelay); + await expect(this.mock.votingPeriod()).to.eventually.equal(votingPeriod); + }); + + describe('set proposal guardian', function () { + it('from governance', async function () { + const governorSigner = await ethers.getSigner(this.mock.target); + await expect(this.mock.connect(governorSigner).setProposalGuardian(this.guardian)) + .to.emit(this.mock, 'ProposalGuardianSet') + .withArgs(ethers.ZeroAddress, this.guardian); + await expect(this.mock.proposalGuardian()).to.eventually.equal(this.guardian); + }); + + it('from non-governance', async function () { + await expect(this.mock.connect(this.other).setProposalGuardian(this.guardian)) + .to.be.revertedWithCustomError(this.mock, 'GovernorOnlyExecutor') + .withArgs(this.other); + }); + }); + + it('cancel proposal during pending state from proposer when proposal guardian is non-zero', async function () { + await this.mock.$_setProposalGuardian(this.guardian); + await this.helper.connect(this.proposer).propose(); + await expect(this.helper.connect(this.proposer).cancel()) + .to.emit(this.mock, 'ProposalCanceled') + .withArgs(this.proposal.id); + }); + + describe('cancel proposal during active state', function () { + beforeEach(async function () { + await this.helper.connect(this.proposer).propose(); + await this.helper.waitForSnapshot(1n); + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active); + }); + + it('from proposal guardian', async function () { + await this.mock.$_setProposalGuardian(this.guardian); + + await expect(this.helper.connect(this.guardian).cancel()) + .to.emit(this.mock, 'ProposalCanceled') + .withArgs(this.proposal.id); + }); + + it('from proposer when proposal guardian is non-zero', async function () { + await this.mock.$_setProposalGuardian(this.guardian); + + await expect(this.helper.connect(this.proposer).cancel()) + .to.be.revertedWithCustomError(this.mock, 'GovernorUnableToCancel') + .withArgs(this.proposal.id, this.proposer); + }); + + it('from proposer when proposal guardian is zero', async function () { + await this.mock.$_setProposalGuardian(ethers.ZeroAddress); + + await expect(this.helper.connect(this.proposer).cancel()) + .to.emit(this.mock, 'ProposalCanceled') + .withArgs(this.proposal.id); + }); + }); + }); + } +}); diff --git a/test/governance/extensions/GovernorSequentialProposalId.test.js b/test/governance/extensions/GovernorSequentialProposalId.test.js new file mode 100644 index 000000000..81bc6eb09 --- /dev/null +++ b/test/governance/extensions/GovernorSequentialProposalId.test.js @@ -0,0 +1,202 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); +const { anyValue } = require('@nomicfoundation/hardhat-chai-matchers/withArgs'); + +const { GovernorHelper } = require('../../helpers/governance'); +const { VoteType } = require('../../helpers/enums'); +const iterate = require('../../helpers/iterate'); + +const TOKENS = [ + { Token: '$ERC20Votes', mode: 'blocknumber' }, + { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' }, +]; + +const name = 'OZ-Governor'; +const version = '1'; +const tokenName = 'MockToken'; +const tokenSymbol = 'MTKN'; +const tokenSupply = ethers.parseEther('100'); +const votingDelay = 4n; +const votingPeriod = 16n; +const value = ethers.parseEther('1'); + +async function deployToken(contractName) { + try { + return await ethers.deployContract(contractName, [tokenName, tokenSymbol, tokenName, version]); + } catch (error) { + if (error.message == 'incorrect number of arguments to constructor') { + // ERC20VotesLegacyMock has a different construction that uses version='1' by default. + return ethers.deployContract(contractName, [tokenName, tokenSymbol, tokenName]); + } + throw error; + } +} + +describe('GovernorSequentialProposalId', function () { + for (const { Token, mode } of TOKENS) { + const fixture = async () => { + const [owner, proposer, voter1, voter2, voter3, voter4, userEOA] = await ethers.getSigners(); + const receiver = await ethers.deployContract('CallReceiverMock'); + + const token = await deployToken(Token, [tokenName, tokenSymbol, version]); + const mock = await ethers.deployContract('$GovernorSequentialProposalIdMock', [ + name, // name + votingDelay, // initialVotingDelay + votingPeriod, // initialVotingPeriod + 0n, // initialProposalThreshold + token, // tokenAddress + 10n, // quorumNumeratorValue + ]); + + await owner.sendTransaction({ to: mock, value }); + await token.$_mint(owner, tokenSupply); + + const helper = new GovernorHelper(mock, mode); + await helper.connect(owner).delegate({ token: token, to: voter1, value: ethers.parseEther('10') }); + await helper.connect(owner).delegate({ token: token, to: voter2, value: ethers.parseEther('7') }); + await helper.connect(owner).delegate({ token: token, to: voter3, value: ethers.parseEther('5') }); + await helper.connect(owner).delegate({ token: token, to: voter4, value: ethers.parseEther('2') }); + + return { + owner, + proposer, + voter1, + voter2, + voter3, + voter4, + userEOA, + receiver, + token, + mock, + helper, + }; + }; + + describe(`using ${Token}`, function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + + this.proposal = this.helper.setProposal( + [ + { + target: this.receiver.target, + data: this.receiver.interface.encodeFunctionData('mockFunction'), + value, + }, + ], + '', + ); + }); + + it('sequential proposal ids', async function () { + for (const i of iterate.range(1, 10)) { + this.proposal.description = ``; + + await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash); + await expect(this.mock.getProposalId(...this.proposal.shortProposal)).revertedWithCustomError( + this.mock, + 'GovernorNonexistentProposal', + ); + await expect(this.mock.latestProposalId()).to.eventually.equal(i - 1); + + await expect(this.helper.connect(this.proposer).propose()) + .to.emit(this.mock, 'ProposalCreated') + .withArgs( + i, + this.proposer, + this.proposal.targets, + this.proposal.values, + this.proposal.signatures, + this.proposal.data, + anyValue, + anyValue, + this.proposal.description, + ); + + await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash); + await expect(this.mock.getProposalId(...this.proposal.shortProposal)).to.eventually.equal(i); + await expect(this.mock.latestProposalId()).to.eventually.equal(i); + } + }); + + it('sequential proposal ids with offset start', async function () { + const offset = 69420; + await this.mock.$_initializeLatestProposalId(offset); + + for (const i of iterate.range(offset + 1, offset + 10)) { + this.proposal.description = ``; + + await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash); + await expect(this.mock.getProposalId(...this.proposal.shortProposal)).revertedWithCustomError( + this.mock, + 'GovernorNonexistentProposal', + ); + await expect(this.mock.latestProposalId()).to.eventually.equal(i - 1); + + await expect(this.helper.connect(this.proposer).propose()) + .to.emit(this.mock, 'ProposalCreated') + .withArgs( + i, + this.proposer, + this.proposal.targets, + this.proposal.values, + this.proposal.signatures, + this.proposal.data, + anyValue, + anyValue, + this.proposal.description, + ); + + await expect(this.mock.hashProposal(...this.proposal.shortProposal)).to.eventually.equal(this.proposal.hash); + await expect(this.mock.getProposalId(...this.proposal.shortProposal)).to.eventually.equal(i); + await expect(this.mock.latestProposalId()).to.eventually.equal(i); + } + }); + + it('can only initialize latest proposal id from 0', async function () { + await this.helper.propose(); + await expect(this.mock.latestProposalId()).to.eventually.equal(1); + await expect(this.mock.$_initializeLatestProposalId(2)).to.be.revertedWithCustomError( + this.mock, + 'GovernorAlreadyInitializedLatestProposalId', + ); + }); + + it('cannot repropose same proposal', async function () { + await this.helper.connect(this.proposer).propose(); + await expect(this.helper.connect(this.proposer).propose()) + .to.be.revertedWithCustomError(this.mock, 'GovernorUnexpectedProposalState') + .withArgs(await this.proposal.id, 0, ethers.ZeroHash); + }); + + it('nominal workflow', async function () { + await this.helper.connect(this.proposer).propose(); + await this.helper.waitForSnapshot(); + + await expect(this.mock.connect(this.voter1).castVote(1, VoteType.For)) + .to.emit(this.mock, 'VoteCast') + .withArgs(this.voter1, 1, VoteType.For, ethers.parseEther('10'), ''); + + await expect(this.mock.connect(this.voter2).castVote(1, VoteType.For)) + .to.emit(this.mock, 'VoteCast') + .withArgs(this.voter2, 1, VoteType.For, ethers.parseEther('7'), ''); + + await expect(this.mock.connect(this.voter3).castVote(1, VoteType.For)) + .to.emit(this.mock, 'VoteCast') + .withArgs(this.voter3, 1, VoteType.For, ethers.parseEther('5'), ''); + + await expect(this.mock.connect(this.voter4).castVote(1, VoteType.Abstain)) + .to.emit(this.mock, 'VoteCast') + .withArgs(this.voter4, 1, VoteType.Abstain, ethers.parseEther('2'), ''); + + await this.helper.waitForDeadline(); + + await expect(this.helper.execute()) + .to.eventually.emit(this.mock, 'ProposalExecuted') + .withArgs(1) + .emit(this.receiver, 'MockFunctionCalled'); + }); + }); + } +}); diff --git a/test/governance/extensions/GovernorStorage.test.js b/test/governance/extensions/GovernorStorage.test.js index ef56fa53e..f079405b5 100644 --- a/test/governance/extensions/GovernorStorage.test.js +++ b/test/governance/extensions/GovernorStorage.test.js @@ -33,7 +33,7 @@ describe('GovernorStorage', function () { const [deployer, owner, proposer, voter1, voter2, voter3, voter4] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const timelock = await ethers.deployContract('TimelockController', [delay, [], [], deployer]); const mock = await ethers.deployContract('$GovernorStorageMock', [ name, diff --git a/test/governance/extensions/GovernorSuperQuorum.test.js b/test/governance/extensions/GovernorSuperQuorum.test.js new file mode 100644 index 000000000..9a8b8455c --- /dev/null +++ b/test/governance/extensions/GovernorSuperQuorum.test.js @@ -0,0 +1,168 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +const { GovernorHelper } = require('../../helpers/governance'); +const { ProposalState, VoteType } = require('../../helpers/enums'); +const time = require('../../helpers/time'); + +const TOKENS = [ + { Token: '$ERC20Votes', mode: 'blocknumber' }, + { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' }, +]; + +const DEFAULT_ADMIN_ROLE = ethers.ZeroHash; +const PROPOSER_ROLE = ethers.id('PROPOSER_ROLE'); +const EXECUTOR_ROLE = ethers.id('EXECUTOR_ROLE'); +const CANCELLER_ROLE = ethers.id('CANCELLER_ROLE'); + +const name = 'OZ-Governor'; +const version = '1'; +const tokenName = 'MockToken'; +const tokenSymbol = 'MTKN'; +const tokenSupply = ethers.parseEther('100'); +const votingDelay = 4n; +const votingPeriod = 16n; +const quorum = 10n; +const superQuorum = 40n; +const value = ethers.parseEther('1'); +const delay = time.duration.hours(1n); + +describe('GovernorSuperQuorum', function () { + for (const { Token, mode } of TOKENS) { + const fixture = async () => { + const [proposer, voter1, voter2, voter3, voter4, voter5] = await ethers.getSigners(); + const receiver = await ethers.deployContract('CallReceiverMock'); + + const timelock = await ethers.deployContract('TimelockController', [delay, [], [], proposer]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); + const mock = await ethers.deployContract('$GovernorSuperQuorumMock', [ + name, + votingDelay, // initialVotingDelay + votingPeriod, // initialVotingPeriod + 0n, // initialProposalThreshold + token, + timelock, + quorum, + superQuorum, + ]); + + await proposer.sendTransaction({ to: timelock, value }); + await token.$_mint(proposer, tokenSupply); + await timelock.grantRole(PROPOSER_ROLE, mock); + await timelock.grantRole(PROPOSER_ROLE, proposer); + await timelock.grantRole(CANCELLER_ROLE, mock); + await timelock.grantRole(CANCELLER_ROLE, proposer); + await timelock.grantRole(EXECUTOR_ROLE, ethers.ZeroAddress); + await timelock.revokeRole(DEFAULT_ADMIN_ROLE, proposer); + + const helper = new GovernorHelper(mock, mode); + await helper.connect(proposer).delegate({ token, to: voter1, value: 40 }); + await helper.connect(proposer).delegate({ token, to: voter2, value: 30 }); + await helper.connect(proposer).delegate({ token, to: voter3, value: 20 }); + await helper.connect(proposer).delegate({ token, to: voter4, value: 15 }); + await helper.connect(proposer).delegate({ token, to: voter5, value: 5 }); + + return { proposer, voter1, voter2, voter3, voter4, voter5, receiver, token, mock, timelock, helper }; + }; + + describe(`using ${Token}`, function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + + // default proposal + this.proposal = this.helper.setProposal( + [ + { + target: this.receiver.target, + value, + data: this.receiver.interface.encodeFunctionData('mockFunction'), + }, + ], + '', + ); + }); + + it('deployment check', async function () { + await expect(this.mock.name()).to.eventually.equal(name); + await expect(this.mock.token()).to.eventually.equal(this.token); + await expect(this.mock.quorum(0)).to.eventually.equal(quorum); + await expect(this.mock.superQuorum(0)).to.eventually.equal(superQuorum); + }); + + it('proposal succeeds early when super quorum is reached', async function () { + await this.helper.connect(this.proposer).propose(); + await this.helper.waitForSnapshot(); + + // Vote with voter2 (30) - above quorum (10) but below super quorum (40) + await this.helper.connect(this.voter2).vote({ support: VoteType.For }); + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active); + + // Vote with voter3 (20) to reach super quorum (50 total > 40) + await this.helper.connect(this.voter3).vote({ support: VoteType.For }); + + await expect(this.mock.proposalEta(this.proposal.id)).to.eventually.equal(0); + + // Should be succeeded since we reached super quorum and no eta is set + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Succeeded); + }); + + it('proposal remains active if super quorum is not reached', async function () { + await this.helper.connect(this.proposer).propose(); + await this.helper.waitForSnapshot(); + + // Vote with voter4 (15) - below super quorum (40) but above quorum (10) + await this.helper.connect(this.voter4).vote({ support: VoteType.For }); + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active); + + // Vote with voter5 (5) - still below super quorum (total 20 < 40) + await this.helper.connect(this.voter5).vote({ support: VoteType.For }); + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active); + + // Wait for deadline + await this.helper.waitForDeadline(1n); + + // Should succeed since deadline passed and we have enough support (20 > 10 quorum) + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Succeeded); + }); + + it('proposal remains active if super quorum is reached but vote fails', async function () { + await this.helper.connect(this.proposer).propose(); + await this.helper.waitForSnapshot(); + + // Vote against with voter2 and voter3 (50) + await this.helper.connect(this.voter2).vote({ support: VoteType.Against }); + await this.helper.connect(this.voter3).vote({ support: VoteType.Against }); + + // Vote for with voter1 (40) (reaching super quorum) + await this.helper.connect(this.voter1).vote({ support: VoteType.For }); + + // should be active since super quorum is reached but vote fails + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active); + + // wait for deadline + await this.helper.waitForDeadline(1n); + + // should be defeated since against votes are higher + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Defeated); + }); + + it('proposal is queued if super quorum is reached and eta is set', async function () { + await this.helper.connect(this.proposer).propose(); + + await this.helper.waitForSnapshot(); + + // Vote with voter1 (40) - reaching super quorum + await this.helper.connect(this.voter1).vote({ support: VoteType.For }); + + await this.helper.queue(); + + // Queueing should set eta + await expect(this.mock.proposalEta(this.proposal.id)).to.eventually.not.equal(0); + + // Should be queued since we reached super quorum and eta is set + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Queued); + }); + }); + } +}); diff --git a/test/governance/extensions/GovernorSuperQuorumGreaterThanQuorum.t.sol b/test/governance/extensions/GovernorSuperQuorumGreaterThanQuorum.t.sol new file mode 100644 index 000000000..eb0409c8e --- /dev/null +++ b/test/governance/extensions/GovernorSuperQuorumGreaterThanQuorum.t.sol @@ -0,0 +1,79 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.20; + +import {Test} from "forge-std/Test.sol"; +import {GovernorVotesSuperQuorumFractionMock} from "../../../contracts/mocks/governance/GovernorVotesSuperQuorumFractionMock.sol"; +import {GovernorVotesQuorumFraction} from "../../../contracts/governance/extensions/GovernorVotesQuorumFraction.sol"; +import {GovernorVotesSuperQuorumFraction} from "../../../contracts/governance/extensions/GovernorVotesSuperQuorumFraction.sol"; +import {GovernorSettings} from "../../../contracts/governance/extensions/GovernorSettings.sol"; +import {GovernorVotes} from "../../../contracts/governance/extensions/GovernorVotes.sol"; +import {Governor} from "../../../contracts/governance/Governor.sol"; +import {IVotes} from "../../../contracts/governance/utils/IVotes.sol"; +import {ERC20VotesExtendedTimestampMock} from "../../../contracts/mocks/token/ERC20VotesAdditionalCheckpointsMock.sol"; +import {EIP712} from "../../../contracts/utils/cryptography/EIP712.sol"; +import {ERC20} from "../../../contracts/token/ERC20/ERC20.sol"; + +contract TokenMock is ERC20VotesExtendedTimestampMock { + constructor() ERC20("Mock Token", "MTK") EIP712("Mock Token", "1") {} +} + +/** + * Main responsibility: expose the functions that are relevant to the simulation + */ +contract GovernorHandler is GovernorVotesSuperQuorumFractionMock { + constructor( + string memory name_, + uint48 votingDelay_, + uint32 votingPeriod_, + uint256 proposalThreshold_, + IVotes token_, + uint256 quorumNumerator_, + uint256 superQuorumNumerator_ + ) + Governor(name_) + GovernorSettings(votingDelay_, votingPeriod_, proposalThreshold_) + GovernorVotes(token_) + GovernorVotesQuorumFraction(quorumNumerator_) + GovernorVotesSuperQuorumFraction(superQuorumNumerator_) + {} + + // solhint-disable-next-line func-name-mixedcase + function $_updateSuperQuorumNumerator(uint256 newSuperQuorumNumerator) public { + _updateSuperQuorumNumerator(newSuperQuorumNumerator); + } + + // solhint-disable-next-line func-name-mixedcase + function $_updateQuorumNumerator(uint256 newQuorumNumerator) public { + _updateQuorumNumerator(newQuorumNumerator); + } +} + +contract GovernorSuperQuorumGreaterThanQuorum is Test { + GovernorHandler private _governorHandler; + + function setUp() external { + _governorHandler = new GovernorHandler( + "GovernorName", + 0, // votingDelay + 1e4, // votingPeriod + 0, // proposalThreshold + new TokenMock(), // token + 10, // quorumNumerator + 50 // superQuorumNumerator + ); + + // limit the fuzzer scope + bytes4[] memory selectors = new bytes4[](2); + selectors[0] = GovernorHandler.$_updateSuperQuorumNumerator.selector; + selectors[1] = GovernorHandler.$_updateQuorumNumerator.selector; + + targetContract(address(_governorHandler)); + targetSelector(FuzzSelector(address(_governorHandler), selectors)); + } + + // solhint-disable-next-line func-name-mixedcase + function invariant_superQuorumGreaterThanQuorum() external view { + assertGe(_governorHandler.superQuorumNumerator(), _governorHandler.quorumNumerator()); + } +} diff --git a/test/governance/extensions/GovernorTimelockAccess.test.js b/test/governance/extensions/GovernorTimelockAccess.test.js index c3d3b3268..5eea6478a 100644 --- a/test/governance/extensions/GovernorTimelockAccess.test.js +++ b/test/governance/extensions/GovernorTimelockAccess.test.js @@ -40,7 +40,7 @@ describe('GovernorTimelockAccess', function () { const manager = await ethers.deployContract('$AccessManager', [admin]); const receiver = await ethers.deployContract('$AccessManagedTarget', [manager]); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const mock = await ethers.deployContract('$GovernorTimelockAccessMock', [ name, votingDelay, diff --git a/test/governance/extensions/GovernorTimelockCompound.test.js b/test/governance/extensions/GovernorTimelockCompound.test.js index 545bf359d..cd82481d5 100644 --- a/test/governance/extensions/GovernorTimelockCompound.test.js +++ b/test/governance/extensions/GovernorTimelockCompound.test.js @@ -28,7 +28,7 @@ describe('GovernorTimelockCompound', function () { const [deployer, owner, voter1, voter2, voter3, voter4, other] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const predictGovernor = await deployer .getNonce() .then(nonce => ethers.getCreateAddress({ from: deployer.address, nonce: nonce + 1 })); diff --git a/test/governance/extensions/GovernorTimelockControl.test.js b/test/governance/extensions/GovernorTimelockControl.test.js index c1156a509..507c7e278 100644 --- a/test/governance/extensions/GovernorTimelockControl.test.js +++ b/test/governance/extensions/GovernorTimelockControl.test.js @@ -34,7 +34,7 @@ describe('GovernorTimelockControl', function () { const [deployer, owner, voter1, voter2, voter3, voter4, other] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const timelock = await ethers.deployContract('TimelockController', [delay, [], [], deployer]); const mock = await ethers.deployContract('$GovernorTimelockControlMock', [ name, diff --git a/test/governance/extensions/GovernorVotesQuorumFraction.test.js b/test/governance/extensions/GovernorVotesQuorumFraction.test.js index 368e396f9..99afd3931 100644 --- a/test/governance/extensions/GovernorVotesQuorumFraction.test.js +++ b/test/governance/extensions/GovernorVotesQuorumFraction.test.js @@ -29,7 +29,7 @@ describe('GovernorVotesQuorumFraction', function () { const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const mock = await ethers.deployContract('$GovernorMock', [name, votingDelay, votingPeriod, 0n, token, ratio]); await owner.sendTransaction({ to: mock, value }); diff --git a/test/governance/extensions/GovernorVotesSuperQuorumFraction.test.js b/test/governance/extensions/GovernorVotesSuperQuorumFraction.test.js new file mode 100644 index 000000000..10a444848 --- /dev/null +++ b/test/governance/extensions/GovernorVotesSuperQuorumFraction.test.js @@ -0,0 +1,160 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +const { GovernorHelper } = require('../../helpers/governance'); +const { ProposalState, VoteType } = require('../../helpers/enums'); +const time = require('../../helpers/time'); + +const TOKENS = [ + { Token: '$ERC20Votes', mode: 'blocknumber' }, + { Token: '$ERC20VotesTimestampMock', mode: 'timestamp' }, +]; + +const name = 'OZ-Governor'; +const version = '1'; +const tokenName = 'MockToken'; +const tokenSymbol = 'MTKN'; +const tokenSupply = ethers.parseEther('100'); +const quorumRatio = 8n; // percents +const superQuorumRatio = 50n; // percents +const newSuperQuorumRatio = 15n; // percents +const votingDelay = 4n; +const votingPeriod = 16n; +const value = ethers.parseEther('1'); + +describe('GovernorVotesSuperQuorumFraction', function () { + for (const { Token, mode } of TOKENS) { + const fixture = async () => { + const [owner, voter1, voter2, voter3, voter4] = await ethers.getSigners(); + const receiver = await ethers.deployContract('CallReceiverMock'); + + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); + const mock = await ethers.deployContract('$GovernorVotesSuperQuorumFractionMock', [ + name, + votingDelay, + votingPeriod, + 0n, + token, + quorumRatio, + superQuorumRatio, + ]); + + await owner.sendTransaction({ to: mock, value }); + await token.$_mint(owner, tokenSupply); + + const helper = new GovernorHelper(mock, mode); + await helper.connect(owner).delegate({ token, to: voter1, value: ethers.parseEther('30') }); + await helper.connect(owner).delegate({ token, to: voter2, value: ethers.parseEther('20') }); + await helper.connect(owner).delegate({ token, to: voter3, value: ethers.parseEther('15') }); + await helper.connect(owner).delegate({ token, to: voter4, value: ethers.parseEther('5') }); + + return { owner, voter1, voter2, voter3, voter4, receiver, token, mock, helper }; + }; + + describe(`using ${Token}`, function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + + // default proposal + this.proposal = this.helper.setProposal( + [ + { + target: this.receiver.target, + value, + data: this.receiver.interface.encodeFunctionData('mockFunction'), + }, + ], + '', + ); + }); + + it('deployment check', async function () { + await expect(this.mock.name()).to.eventually.equal(name); + await expect(this.mock.token()).to.eventually.equal(this.token); + await expect(this.mock.votingDelay()).to.eventually.equal(votingDelay); + await expect(this.mock.votingPeriod()).to.eventually.equal(votingPeriod); + await expect(this.mock.quorumNumerator()).to.eventually.equal(quorumRatio); + await expect(this.mock.superQuorumNumerator()).to.eventually.equal(superQuorumRatio); + await expect(this.mock.quorumDenominator()).to.eventually.equal(100n); + await expect(time.clock[mode]().then(clock => this.mock.superQuorum(clock - 1n))).to.eventually.equal( + (tokenSupply * superQuorumRatio) / 100n, + ); + }); + + it('proposal remains active until super quorum is reached', async function () { + await this.helper.propose(); + await this.helper.waitForSnapshot(); + + // Vote with voter1 (30%) - above quorum (8%) but below super quorum (50%) + await this.helper.connect(this.voter1).vote({ support: VoteType.For }); + + // Check proposal is still active + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Active); + + // Vote with voter2 (20%) - now matches super quorum + await this.helper.connect(this.voter2).vote({ support: VoteType.For }); + + // Proposal should no longer be active + await expect(this.mock.state(this.proposal.id)).to.eventually.equal(ProposalState.Succeeded); + }); + + describe('super quorum updates', function () { + it('updateSuperQuorumNumerator is protected', async function () { + await expect(this.mock.connect(this.owner).updateSuperQuorumNumerator(newSuperQuorumRatio)) + .to.be.revertedWithCustomError(this.mock, 'GovernorOnlyExecutor') + .withArgs(this.owner); + }); + + it('can update super quorum through governance', async function () { + this.helper.setProposal( + [ + { + target: this.mock.target, + data: this.mock.interface.encodeFunctionData('updateSuperQuorumNumerator', [newSuperQuorumRatio]), + }, + ], + '', + ); + + await this.helper.propose(); + await this.helper.waitForSnapshot(); + await this.helper.connect(this.voter1).vote({ support: VoteType.For }); + await this.helper.connect(this.voter2).vote({ support: VoteType.For }); + await this.helper.waitForDeadline(); + + await expect(this.helper.execute()) + .to.emit(this.mock, 'SuperQuorumNumeratorUpdated') + .withArgs(superQuorumRatio, newSuperQuorumRatio); + + await expect(this.mock.superQuorumNumerator()).to.eventually.equal(newSuperQuorumRatio); + }); + + it('cannot set super quorum below quorum', async function () { + const invalidSuperQuorum = quorumRatio - 1n; + + await expect(this.mock.$_updateSuperQuorumNumerator(invalidSuperQuorum)) + .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidSuperQuorumTooSmall') + .withArgs(invalidSuperQuorum, quorumRatio); + }); + + it('cannot set super quorum above denominator', async function () { + const denominator = await this.mock.quorumDenominator(); + const invalidSuperQuorum = BigInt(denominator) + 1n; + + await expect(this.mock.$_updateSuperQuorumNumerator(invalidSuperQuorum)) + .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidSuperQuorumFraction') + .withArgs(invalidSuperQuorum, denominator); + }); + + it('cannot set quorum above super quorum', async function () { + const invalidQuorum = superQuorumRatio + 1n; + + await expect(this.mock.$_updateQuorumNumerator(invalidQuorum)) + .to.be.revertedWithCustomError(this.mock, 'GovernorInvalidQuorumTooLarge') + .withArgs(invalidQuorum, superQuorumRatio); + }); + }); + }); + } +}); diff --git a/test/governance/extensions/GovernorWithParams.test.js b/test/governance/extensions/GovernorWithParams.test.js index 37e15f5c2..db19bc616 100644 --- a/test/governance/extensions/GovernorWithParams.test.js +++ b/test/governance/extensions/GovernorWithParams.test.js @@ -31,7 +31,7 @@ describe('GovernorWithParams', function () { const [owner, proposer, voter1, voter2, voter3, voter4, other] = await ethers.getSigners(); const receiver = await ethers.deployContract('CallReceiverMock'); - const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, version]); + const token = await ethers.deployContract(Token, [tokenName, tokenSymbol, tokenName, version]); const mock = await ethers.deployContract('$GovernorWithParamsMock', [name, token]); await owner.sendTransaction({ to: mock, value }); diff --git a/test/helpers/constants.js b/test/helpers/constants.js index 4dfda5eab..eb9b43e55 100644 --- a/test/helpers/constants.js +++ b/test/helpers/constants.js @@ -1,4 +1,5 @@ module.exports = { + MAX_UINT32: 2n ** 32n - 1n, MAX_UINT48: 2n ** 48n - 1n, MAX_UINT64: 2n ** 64n - 1n, }; diff --git a/test/helpers/enums.js b/test/helpers/enums.js index f95767ab7..6adbf64ad 100644 --- a/test/helpers/enums.js +++ b/test/helpers/enums.js @@ -1,12 +1,14 @@ -function Enum(...options) { - return Object.fromEntries(options.map((key, i) => [key, BigInt(i)])); -} +const { ethers } = require('ethers'); + +const Enum = (...options) => Object.fromEntries(options.map((key, i) => [key, BigInt(i)])); +const EnumTyped = (...options) => Object.fromEntries(options.map((key, i) => [key, ethers.Typed.uint8(i)])); module.exports = { Enum, + EnumTyped, ProposalState: Enum('Pending', 'Active', 'Canceled', 'Defeated', 'Succeeded', 'Queued', 'Expired', 'Executed'), VoteType: Object.assign(Enum('Against', 'For', 'Abstain'), { Parameters: 255n }), - Rounding: Enum('Floor', 'Ceil', 'Trunc', 'Expand'), + Rounding: EnumTyped('Floor', 'Ceil', 'Trunc', 'Expand'), OperationState: Enum('Unset', 'Waiting', 'Ready', 'Done'), - RevertType: Enum('None', 'RevertWithoutMessage', 'RevertWithMessage', 'RevertWithCustomError', 'Panic'), + RevertType: EnumTyped('None', 'RevertWithoutMessage', 'RevertWithMessage', 'RevertWithCustomError', 'Panic'), }; diff --git a/test/helpers/erc4337-entrypoint.js b/test/helpers/erc4337-entrypoint.js deleted file mode 100644 index aba49f4c4..000000000 --- a/test/helpers/erc4337-entrypoint.js +++ /dev/null @@ -1,31 +0,0 @@ -const { ethers } = require('hardhat'); -const { setCode } = require('@nomicfoundation/hardhat-network-helpers'); -const fs = require('fs'); -const path = require('path'); - -const INSTANCES = { - entrypoint: { - address: '0x0000000071727De22E5E9d8BAf0edAc6f37da032', - abi: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../bin/EntryPoint070.abi'), 'utf-8')), - bytecode: fs.readFileSync(path.resolve(__dirname, '../bin/EntryPoint070.bytecode'), 'hex'), - }, - sendercreator: { - address: '0xEFC2c1444eBCC4Db75e7613d20C6a62fF67A167C', - abi: JSON.parse(fs.readFileSync(path.resolve(__dirname, '../bin/SenderCreator070.abi'), 'utf-8')), - bytecode: fs.readFileSync(path.resolve(__dirname, '../bin/SenderCreator070.bytecode'), 'hex'), - }, -}; - -function deployEntrypoint() { - return Promise.all( - Object.entries(INSTANCES).map(([name, { address, abi, bytecode }]) => - setCode(address, '0x' + bytecode.replace(/0x/, '')) - .then(() => ethers.getContractAt(abi, address)) - .then(instance => ({ [name]: instance })), - ), - ).then(namedInstances => Object.assign(...namedInstances)); -} - -module.exports = { - deployEntrypoint, -}; diff --git a/test/helpers/erc4337.js b/test/helpers/erc4337.js index 50a3b4a04..2d5cbe1a0 100644 --- a/test/helpers/erc4337.js +++ b/test/helpers/erc4337.js @@ -78,26 +78,8 @@ class UserOperation { }; } - hash(entrypoint, chainId) { - const p = this.packed; - const h = ethers.keccak256( - ethers.AbiCoder.defaultAbiCoder().encode( - ['address', 'uint256', 'bytes32', 'bytes32', 'uint256', 'uint256', 'uint256', 'uint256'], - [ - p.sender, - p.nonce, - ethers.keccak256(p.initCode), - ethers.keccak256(p.callData), - p.accountGasLimits, - p.preVerificationGas, - p.gasFees, - ethers.keccak256(p.paymasterAndData), - ], - ), - ); - return ethers.keccak256( - ethers.AbiCoder.defaultAbiCoder().encode(['bytes32', 'address', 'uint256'], [h, getAddress(entrypoint), chainId]), - ); + hash(entrypoint) { + return entrypoint.getUserOpHash(this.packed); } } diff --git a/test/helpers/governance.js b/test/helpers/governance.js index 540967af4..e0686445c 100644 --- a/test/helpers/governance.js +++ b/test/helpers/governance.js @@ -35,12 +35,16 @@ class GovernorHelper { return this; } - get id() { + get hash() { return ethers.keccak256( ethers.AbiCoder.defaultAbiCoder().encode(['address[]', 'uint256[]', 'bytes[]', 'bytes32'], this.shortProposal), ); } + get id() { + return this.governor.latestProposalId ? this.governor.getProposalId(...this.shortProposal) : this.hash; + } + // used for checking events get signatures() { return this.data.map(() => ''); @@ -106,10 +110,10 @@ class GovernorHelper { async vote(vote = {}) { let method = 'castVote'; // default - let args = [this.id, vote.support]; // base + let args = [await this.id, vote.support]; // base if (vote.signature) { - const sign = await vote.signature(this.governor, this.forgeMessage(vote)); + const sign = await this.forgeMessage(vote).then(msg => vote.signature(this.governor, msg)); if (vote.params || vote.reason) { method = 'castVoteWithReasonAndParamsBySig'; args.push(vote.voter, vote.reason ?? '', vote.params ?? '0x', sign); @@ -130,14 +134,12 @@ class GovernorHelper { async overrideVote(vote = {}) { let method = 'castOverrideVote'; - let args = [this.id, vote.support]; + let args = [await this.id, vote.support]; vote.reason = vote.reason ?? ''; if (vote.signature) { - let message = this.forgeMessage(vote); - message.reason = message.reason ?? ''; - const sign = await vote.signature(this.governor, message); + const sign = await this.forgeMessage(vote).then(msg => vote.signature(this.governor, { reason: '', ...msg })); method = 'castOverrideVoteBySig'; args.push(vote.voter, vote.reason ?? '', sign); } @@ -147,23 +149,23 @@ class GovernorHelper { /// Clock helpers async waitForSnapshot(offset = 0n) { - const timepoint = await this.governor.proposalSnapshot(this.id); + const timepoint = await this.governor.proposalSnapshot(await this.id); return time.increaseTo[this.mode](timepoint + offset); } async waitForDeadline(offset = 0n) { - const timepoint = await this.governor.proposalDeadline(this.id); + const timepoint = await this.governor.proposalDeadline(await this.id); return time.increaseTo[this.mode](timepoint + offset); } async waitForEta(offset = 0n) { - const timestamp = await this.governor.proposalEta(this.id); + const timestamp = await this.governor.proposalEta(await this.id); return time.increaseTo.timestamp(timestamp + offset); } /// Other helpers - forgeMessage(vote = {}) { - const message = { proposalId: this.id, support: vote.support, voter: vote.voter, nonce: vote.nonce }; + async forgeMessage(vote = {}) { + const message = { proposalId: await this.id, support: vote.support, voter: vote.voter, nonce: vote.nonce }; if (vote.params || vote.reason) { message.reason = vote.reason ?? ''; diff --git a/test/helpers/iterate.js b/test/helpers/iterate.js index c7403d523..8c8e9649d 100644 --- a/test/helpers/iterate.js +++ b/test/helpers/iterate.js @@ -30,7 +30,12 @@ module.exports = { // ================================================ Object helpers ================================================= - // Create a new object by mapping the values through a function, keeping the keys + // Create a new object by mapping the values through a function, keeping the keys. Second function can be used to pre-filter entries // Example: mapValues({a:1,b:2,c:3}, x => x**2) → {a:1,b:4,c:9} - mapValues: (obj, fn) => Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, fn(v)])), + mapValues: (obj, fn, fn2 = () => true) => + Object.fromEntries( + Object.entries(obj) + .filter(fn2) + .map(([k, v]) => [k, fn(v)]), + ), }; diff --git a/test/helpers/precompiles.js b/test/helpers/precompiles.js new file mode 100644 index 000000000..fb6b7132a --- /dev/null +++ b/test/helpers/precompiles.js @@ -0,0 +1,12 @@ +module.exports = { + ecRecover: '0x0000000000000000000000000000000000000001', + SHA2_256: '0x0000000000000000000000000000000000000002', + RIPEMD_160: '0x0000000000000000000000000000000000000003', + identity: '0x0000000000000000000000000000000000000004', + modexp: '0x0000000000000000000000000000000000000005', + ecAdd: '0x0000000000000000000000000000000000000006', + ecMul: '0x0000000000000000000000000000000000000007', + ecPairing: '0x0000000000000000000000000000000000000008', + blake2f: '0x0000000000000000000000000000000000000009', + pointEvaluation: '0x000000000000000000000000000000000000000a', +}; diff --git a/test/helpers/time.js b/test/helpers/time.js index f6ccc3cab..574170c13 100644 --- a/test/helpers/time.js +++ b/test/helpers/time.js @@ -7,8 +7,11 @@ const clock = { timestamp: () => time.latest().then(ethers.toBigInt), }; const clockFromReceipt = { - blocknumber: receipt => Promise.resolve(ethers.toBigInt(receipt.blockNumber)), - timestamp: receipt => ethers.provider.getBlock(receipt.blockNumber).then(block => ethers.toBigInt(block.timestamp)), + blocknumber: receipt => Promise.resolve(receipt).then(({ blockNumber }) => ethers.toBigInt(blockNumber)), + timestamp: receipt => + Promise.resolve(receipt) + .then(({ blockNumber }) => ethers.provider.getBlock(blockNumber)) + .then(({ timestamp }) => ethers.toBigInt(timestamp)), }; const increaseBy = { blockNumber: mine, diff --git a/test/metatx/ERC2771Context.test.js b/test/metatx/ERC2771Context.test.js index 15da61dad..ce139961c 100644 --- a/test/metatx/ERC2771Context.test.js +++ b/test/metatx/ERC2771Context.test.js @@ -11,7 +11,7 @@ const { shouldBehaveLikeRegularContext } = require('../utils/Context.behavior'); async function fixture() { const [sender, other] = await ethers.getSigners(); - const forwarder = await ethers.deployContract('ERC2771Forwarder', []); + const forwarder = await ethers.deployContract('ERC2771Forwarder', ['ERC2771Forwarder']); const forwarderAsSigner = await impersonate(forwarder.target); const context = await ethers.deployContract('ERC2771ContextMock', [forwarder]); const domain = await getDomain(forwarder); @@ -109,7 +109,7 @@ describe('ERC2771Context', function () { const nonce = await this.forwarder.nonces(this.sender); const data = this.context.interface.encodeFunctionData('multicall', [ [ - // poisonned call to 'msgSender()' + // poisoned call to 'msgSender()' ethers.concat([this.context.interface.encodeFunctionData('msgSender'), this.other.address]), ], ]); diff --git a/test/metatx/ERC2771Forwarder.t.sol b/test/metatx/ERC2771Forwarder.t.sol index e6baac6f0..605ae6209 100644 --- a/test/metatx/ERC2771Forwarder.t.sol +++ b/test/metatx/ERC2771Forwarder.t.sol @@ -171,7 +171,7 @@ contract ERC2771ForwarderTest is Test { uint256 refundExpected = 0; uint256 nonce = _erc2771Forwarder.nonces(_signer); - // create an sign array or requests (that may fail) + // create an array of signed requests (that may fail) ERC2771Forwarder.ForwardRequestData[] memory requests = new ERC2771Forwarder.ForwardRequestData[](batchSize); for (uint256 i = 0; i < batchSize; ++i) { bool failure = (seed >> i) & 0x1 == 0x1; @@ -229,7 +229,7 @@ contract ERC2771ForwarderTest is Test { TamperType tamper = _asTamper(_tamper); uint256 nonce = _erc2771Forwarder.nonces(_signer); - // create an sign array or requests + // create an array of signed requests ERC2771Forwarder.ForwardRequestData[] memory requests = new ERC2771Forwarder.ForwardRequestData[](3); for (uint256 i = 0; i < requests.length; ++i) { requests[i] = _forgeRequestData({ @@ -252,7 +252,7 @@ contract ERC2771ForwarderTest is Test { TamperType tamper = _asTamper(_tamper); uint256 nonce = _erc2771Forwarder.nonces(_signer); - // create an sign array or requests + // create an array of signed requests ERC2771Forwarder.ForwardRequestData[] memory requests = new ERC2771Forwarder.ForwardRequestData[](3); for (uint256 i = 0; i < requests.length; ++i) { requests[i] = _forgeRequestData({ diff --git a/test/proxy/Clones.t.sol b/test/proxy/Clones.t.sol index e589ba906..5da6d56d5 100644 --- a/test/proxy/Clones.t.sol +++ b/test/proxy/Clones.t.sol @@ -10,7 +10,7 @@ contract ClonesTest is Test { return 42; } - function testSymbolicPredictDeterministicAddressSpillage(address implementation, bytes32 salt) public { + function testSymbolicPredictDeterministicAddressSpillage(address implementation, bytes32 salt) public view { address predicted = Clones.predictDeterministicAddress(implementation, salt); bytes32 spillage; assembly ("memory-safe") { @@ -23,7 +23,7 @@ contract ClonesTest is Test { address implementation, bytes32 salt, bytes memory args - ) public { + ) public view { vm.assume(args.length < 0xbfd3); address predicted = Clones.predictDeterministicAddressWithImmutableArgs(implementation, args, salt); @@ -59,7 +59,7 @@ contract ClonesTest is Test { assertEq(ClonesTest(cloneDirty).getNumber(), this.getNumber()); } - function testPredictDeterministicAddressDirty(bytes32 salt) external { + function testPredictDeterministicAddressDirty(bytes32 salt) external view { address predictClean = Clones.predictDeterministicAddress(address(this), salt); address predictDirty = Clones.predictDeterministicAddress(_dirty(address(this)), salt); diff --git a/test/proxy/beacon/BeaconProxy.test.js b/test/proxy/beacon/BeaconProxy.test.js index 0a0878446..d64023bbc 100644 --- a/test/proxy/beacon/BeaconProxy.test.js +++ b/test/proxy/beacon/BeaconProxy.test.js @@ -34,7 +34,7 @@ describe('BeaconProxy', function () { it('non-compliant beacon', async function () { const badBeacon = await ethers.deployContract('BadBeaconNoImpl'); - // BadBeaconNoImpl does not provide `implementation()` has no fallback. + // BadBeaconNoImpl does not provide `implementation()` and has no fallback. // This causes ERC1967Utils._setBeacon to revert. await expect(this.newBeaconProxy(badBeacon, '0x')).to.be.revertedWithoutReason(); }); diff --git a/test/token/ERC20/extensions/ERC20Wrapper.test.js b/test/token/ERC20/extensions/ERC20Wrapper.test.js index 9e72e1a92..2f630e638 100644 --- a/test/token/ERC20/extensions/ERC20Wrapper.test.js +++ b/test/token/ERC20/extensions/ERC20Wrapper.test.js @@ -77,7 +77,7 @@ describe('ERC20Wrapper', function () { .withArgs(this.token, 0, initialSupply); }); - it('reverts when inssuficient balance', async function () { + it('reverts when insufficient balance', async function () { await this.underlying.connect(this.holder).approve(this.token, ethers.MaxUint256); await expect(this.token.connect(this.holder).depositFor(this.holder, ethers.MaxUint256)) @@ -117,7 +117,7 @@ describe('ERC20Wrapper', function () { await this.token.connect(this.holder).depositFor(this.holder, initialSupply); }); - it('reverts when inssuficient balance', async function () { + it('reverts when insufficient balance', async function () { await expect(this.token.connect(this.holder).withdrawTo(this.holder, ethers.MaxInt256)) .to.be.revertedWithCustomError(this.token, 'ERC20InsufficientBalance') .withArgs(this.holder, initialSupply, ethers.MaxInt256); diff --git a/test/token/ERC20/extensions/ERC4626.test.js b/test/token/ERC20/extensions/ERC4626.test.js index 71c7cbaaf..ad8c92691 100644 --- a/test/token/ERC20/extensions/ERC4626.test.js +++ b/test/token/ERC20/extensions/ERC4626.test.js @@ -130,10 +130,10 @@ describe('ERC4626', function () { expect(await this.vault.previewWithdraw(value)).to.equal(sharesForWithdraw); }); - // Donate newly minted tokens to the vault during the reentracy causes the share price to increase. - // Still, the deposit that trigger the reentracy is not affected and get the previewed price. + // Donate newly minted tokens to the vault during the reentrancy causes the share price to increase. + // Still, the deposit that trigger the reentrancy is not affected and get the previewed price. // Further deposits will get a different price (getting fewer shares for the same value of assets) - it('share price change during reentracy does not affect deposit', async function () { + it('share price change during reentrancy does not affect deposit', async function () { // Schedules a reentrancy from the token contract that mess up the share price await this.token.scheduleReenter( reenterType.Before, @@ -154,10 +154,10 @@ describe('ERC4626', function () { expect(await this.vault.previewDeposit(value)).to.lt(sharesBefore); }); - // Burn some tokens from the vault during the reentracy causes the share price to drop. - // Still, the withdraw that trigger the reentracy is not affected and get the previewed price. + // Burn some tokens from the vault during the reentrancy causes the share price to drop. + // Still, the withdraw that trigger the reentrancy is not affected and get the previewed price. // Further withdraw will get a different price (needing more shares for the same value of assets) - it('share price change during reentracy does not affect withdraw', async function () { + it('share price change during reentrancy does not affect withdraw', async function () { await this.vault.connect(this.holder).deposit(value, this.holder); await this.vault.connect(this.other).deposit(value, this.other); diff --git a/test/token/ERC20/utils/SafeERC20.test.js b/test/token/ERC20/utils/SafeERC20.test.js index 16b72bd6b..0ae94630d 100644 --- a/test/token/ERC20/utils/SafeERC20.test.js +++ b/test/token/ERC20/utils/SafeERC20.test.js @@ -60,12 +60,24 @@ describe('SafeERC20', function () { .withArgs(this.token); }); + it('returns false on trySafeTransfer', async function () { + await expect(this.mock.$trySafeTransfer(this.token, this.receiver, 0n)) + .to.emit(this.mock, 'return$trySafeTransfer') + .withArgs(false); + }); + it('reverts on transferFrom', async function () { await expect(this.mock.$safeTransferFrom(this.token, this.mock, this.receiver, 0n)) .to.be.revertedWithCustomError(this.mock, 'SafeERC20FailedOperation') .withArgs(this.token); }); + it('returns false on trySafeTransferFrom', async function () { + await expect(this.mock.$trySafeTransferFrom(this.token, this.mock, this.receiver, 0n)) + .to.emit(this.mock, 'return$trySafeTransferFrom') + .withArgs(false); + }); + it('reverts on increaseAllowance', async function () { // Call to 'token.allowance' does not return any data, resulting in a decoding error (revert without reason) await expect(this.mock.$safeIncreaseAllowance(this.token, this.spender, 0n)).to.be.revertedWithoutReason(); @@ -94,12 +106,24 @@ describe('SafeERC20', function () { .withArgs(this.token); }); + it('returns false on trySafeTransfer', async function () { + await expect(this.mock.$trySafeTransfer(this.token, this.receiver, 0n)) + .to.emit(this.mock, 'return$trySafeTransfer') + .withArgs(false); + }); + it('reverts on transferFrom', async function () { await expect(this.mock.$safeTransferFrom(this.token, this.mock, this.receiver, 0n)) .to.be.revertedWithCustomError(this.mock, 'SafeERC20FailedOperation') .withArgs(this.token); }); + it('returns false on trySafeTransferFrom', async function () { + await expect(this.mock.$trySafeTransferFrom(this.token, this.mock, this.receiver, 0n)) + .to.emit(this.mock, 'return$trySafeTransferFrom') + .withArgs(false); + }); + it('reverts on increaseAllowance', async function () { await expect(this.mock.$safeIncreaseAllowance(this.token, this.spender, 0n)) .to.be.revertedWithCustomError(this.mock, 'SafeERC20FailedOperation') @@ -357,11 +381,23 @@ function shouldOnlyRevertOnErrors() { .withArgs(this.mock, this.receiver, 10n); }); + it('returns true on trySafeTransfer', async function () { + await expect(this.mock.$trySafeTransfer(this.token, this.receiver, 10n)) + .to.emit(this.mock, 'return$trySafeTransfer') + .withArgs(true); + }); + it("doesn't revert on transferFrom", async function () { await expect(this.mock.$safeTransferFrom(this.token, this.owner, this.receiver, 10n)) .to.emit(this.token, 'Transfer') .withArgs(this.owner, this.receiver, 10n); }); + + it('returns true on trySafeTransferFrom', async function () { + await expect(this.mock.$trySafeTransferFrom(this.token, this.owner, this.receiver, 10n)) + .to.emit(this.mock, 'return$trySafeTransferFrom') + .withArgs(true); + }); }); describe('approvals', function () { diff --git a/test/token/ERC6909/ERC6909.behavior.js b/test/token/ERC6909/ERC6909.behavior.js new file mode 100644 index 000000000..adfe15a32 --- /dev/null +++ b/test/token/ERC6909/ERC6909.behavior.js @@ -0,0 +1,216 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); + +const { shouldSupportInterfaces } = require('../../utils/introspection/SupportsInterface.behavior'); + +function shouldBehaveLikeERC6909() { + const firstTokenId = 1n; + const secondTokenId = 2n; + const randomTokenId = 125523n; + + const firstTokenSupply = 2000n; + const secondTokenSupply = 3000n; + const amount = 100n; + + describe('like an ERC6909', function () { + describe('balanceOf', function () { + describe("when accounts don't own tokens", function () { + it('return zero', async function () { + await expect(this.token.balanceOf(this.holder, firstTokenId)).to.eventually.be.equal(0n); + await expect(this.token.balanceOf(this.holder, secondTokenId)).to.eventually.be.equal(0n); + await expect(this.token.balanceOf(this.other, randomTokenId)).to.eventually.be.equal(0n); + }); + }); + + describe('when accounts own some tokens', function () { + beforeEach(async function () { + await this.token.$_mint(this.holder, firstTokenId, firstTokenSupply); + await this.token.$_mint(this.holder, secondTokenId, secondTokenSupply); + }); + + it('returns amount owned by the given address', async function () { + await expect(this.token.balanceOf(this.holder, firstTokenId)).to.eventually.be.equal(firstTokenSupply); + await expect(this.token.balanceOf(this.holder, secondTokenId)).to.eventually.be.equal(secondTokenSupply); + await expect(this.token.balanceOf(this.other, firstTokenId)).to.eventually.be.equal(0n); + }); + }); + }); + + describe('setOperator', function () { + it('emits an OperatorSet event and updated the value', async function () { + await expect(this.token.connect(this.holder).setOperator(this.operator, true)) + .to.emit(this.token, 'OperatorSet') + .withArgs(this.holder, this.operator, true); + + // operator for holder + await expect(this.token.isOperator(this.holder, this.operator)).to.eventually.be.true; + + // not operator for other account + await expect(this.token.isOperator(this.other, this.operator)).to.eventually.be.false; + }); + + it('can unset the operator approval', async function () { + await this.token.connect(this.holder).setOperator(this.operator, true); + + // before + await expect(this.token.isOperator(this.holder, this.operator)).to.eventually.be.true; + + // unset + await expect(this.token.connect(this.holder).setOperator(this.operator, false)) + .to.emit(this.token, 'OperatorSet') + .withArgs(this.holder, this.operator, false); + + // after + await expect(this.token.isOperator(this.holder, this.operator)).to.eventually.be.false; + }); + + it('cannot set address(0) as an operator', async function () { + await expect(this.token.connect(this.holder).setOperator(ethers.ZeroAddress, true)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidSpender') + .withArgs(ethers.ZeroAddress); + }); + }); + + describe('approve', function () { + it('emits an Approval event and updates allowance', async function () { + await expect(this.token.connect(this.holder).approve(this.operator, firstTokenId, firstTokenSupply)) + .to.emit(this.token, 'Approval') + .withArgs(this.holder, this.operator, firstTokenId, firstTokenSupply); + + // approved + await expect(this.token.allowance(this.holder, this.operator, firstTokenId)).to.eventually.be.equal( + firstTokenSupply, + ); + // other account is not approved + await expect(this.token.allowance(this.other, this.operator, firstTokenId)).to.eventually.be.equal(0n); + }); + + it('can unset the approval', async function () { + await expect(this.token.connect(this.holder).approve(this.operator, firstTokenId, 0n)) + .to.emit(this.token, 'Approval') + .withArgs(this.holder, this.operator, firstTokenId, 0n); + await expect(this.token.allowance(this.holder, this.operator, firstTokenId)).to.eventually.be.equal(0n); + }); + + it('cannot give allowance to address(0)', async function () { + await expect(this.token.connect(this.holder).approve(ethers.ZeroAddress, firstTokenId, firstTokenSupply)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidSpender') + .withArgs(ethers.ZeroAddress); + }); + }); + + describe('transfer', function () { + beforeEach(async function () { + await this.token.$_mint(this.holder, firstTokenId, firstTokenSupply); + await this.token.$_mint(this.holder, secondTokenId, secondTokenSupply); + }); + + it('transfers to the zero address are blocked', async function () { + await expect(this.token.connect(this.holder).transfer(ethers.ZeroAddress, firstTokenId, firstTokenSupply)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidReceiver') + .withArgs(ethers.ZeroAddress); + }); + + it('reverts when insufficient balance', async function () { + await expect(this.token.connect(this.holder).transfer(this.recipient, firstTokenId, firstTokenSupply + 1n)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InsufficientBalance') + .withArgs(this.holder, firstTokenSupply, firstTokenSupply + 1n, firstTokenId); + }); + + it('emits event and transfers tokens', async function () { + await expect(this.token.connect(this.holder).transfer(this.recipient, firstTokenId, amount)) + .to.emit(this.token, 'Transfer') + .withArgs(this.holder, this.holder, this.recipient, firstTokenId, amount); + + await expect(this.token.balanceOf(this.holder, firstTokenId)).to.eventually.equal(firstTokenSupply - amount); + await expect(this.token.balanceOf(this.recipient, firstTokenId)).to.eventually.equal(amount); + }); + }); + + describe('transferFrom', function () { + beforeEach(async function () { + await this.token.$_mint(this.holder, firstTokenId, firstTokenSupply); + await this.token.$_mint(this.holder, secondTokenId, secondTokenSupply); + }); + + it('transfer from self', async function () { + await expect(this.token.connect(this.holder).transferFrom(this.holder, this.recipient, firstTokenId, amount)) + .to.emit(this.token, 'Transfer') + .withArgs(this.holder, this.holder, this.recipient, firstTokenId, amount); + + await expect(this.token.balanceOf(this.holder, firstTokenId)).to.eventually.equal(firstTokenSupply - amount); + await expect(this.token.balanceOf(this.recipient, firstTokenId)).to.eventually.equal(amount); + }); + + describe('with approval', async function () { + beforeEach(async function () { + await this.token.connect(this.holder).approve(this.operator, firstTokenId, amount); + }); + + it('reverts when insufficient allowance', async function () { + await expect( + this.token.connect(this.operator).transferFrom(this.holder, this.recipient, firstTokenId, amount + 1n), + ) + .to.be.revertedWithCustomError(this.token, 'ERC6909InsufficientAllowance') + .withArgs(this.operator, amount, amount + 1n, firstTokenId); + }); + + it('should emit transfer event and update approval (without an Approval event)', async function () { + await expect( + this.token.connect(this.operator).transferFrom(this.holder, this.recipient, firstTokenId, amount - 1n), + ) + .to.emit(this.token, 'Transfer') + .withArgs(this.operator, this.holder, this.recipient, firstTokenId, amount - 1n) + .to.not.emit(this.token, 'Approval'); + + await expect(this.token.allowance(this.holder, this.operator, firstTokenId)).to.eventually.equal(1n); + }); + + it("shouldn't reduce allowance when infinite", async function () { + await this.token.connect(this.holder).approve(this.operator, firstTokenId, ethers.MaxUint256); + + await this.token.connect(this.operator).transferFrom(this.holder, this.recipient, firstTokenId, amount); + + await expect(this.token.allowance(this.holder, this.operator, firstTokenId)).to.eventually.equal( + ethers.MaxUint256, + ); + }); + }); + }); + + describe('with operator approval', function () { + beforeEach(async function () { + await this.token.connect(this.holder).setOperator(this.operator, true); + await this.token.$_mint(this.holder, firstTokenId, firstTokenSupply); + }); + + it('operator can transfer', async function () { + await expect(this.token.connect(this.operator).transferFrom(this.holder, this.recipient, firstTokenId, amount)) + .to.emit(this.token, 'Transfer') + .withArgs(this.operator, this.holder, this.recipient, firstTokenId, amount); + + await expect(this.token.balanceOf(this.holder, firstTokenId)).to.eventually.equal(firstTokenSupply - amount); + await expect(this.token.balanceOf(this.recipient, firstTokenId)).to.eventually.equal(amount); + }); + + it('operator transfer does not reduce allowance', async function () { + // Also give allowance + await this.token.connect(this.holder).approve(this.operator, firstTokenId, firstTokenSupply); + + await expect(this.token.connect(this.operator).transferFrom(this.holder, this.recipient, firstTokenId, amount)) + .to.emit(this.token, 'Transfer') + .withArgs(this.operator, this.holder, this.recipient, firstTokenId, amount); + + await expect(this.token.allowance(this.holder, this.operator, firstTokenId)).to.eventually.equal( + firstTokenSupply, + ); + }); + }); + + shouldSupportInterfaces(['ERC6909']); + }); +} + +module.exports = { + shouldBehaveLikeERC6909, +}; diff --git a/test/token/ERC6909/ERC6909.test.js b/test/token/ERC6909/ERC6909.test.js new file mode 100644 index 000000000..fa41145aa --- /dev/null +++ b/test/token/ERC6909/ERC6909.test.js @@ -0,0 +1,104 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +const { shouldBehaveLikeERC6909 } = require('./ERC6909.behavior'); + +async function fixture() { + const [holder, operator, recipient, other] = await ethers.getSigners(); + const token = await ethers.deployContract('$ERC6909'); + return { token, holder, operator, recipient, other }; +} + +describe('ERC6909', function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeERC6909(); + + describe('internal functions', function () { + const tokenId = 1990n; + const mintValue = 9001n; + const burnValue = 3000n; + + describe('_mint', function () { + it('reverts with a zero destination address', async function () { + await expect(this.token.$_mint(ethers.ZeroAddress, tokenId, mintValue)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidReceiver') + .withArgs(ethers.ZeroAddress); + }); + + describe('with minted tokens', function () { + beforeEach(async function () { + this.tx = await this.token.connect(this.operator).$_mint(this.holder, tokenId, mintValue); + }); + + it('emits a Transfer event from 0 address', async function () { + await expect(this.tx) + .to.emit(this.token, 'Transfer') + .withArgs(this.operator, ethers.ZeroAddress, this.holder, tokenId, mintValue); + }); + + it('credits the minted token value', async function () { + await expect(this.token.balanceOf(this.holder, tokenId)).to.eventually.be.equal(mintValue); + }); + }); + }); + + describe('_transfer', function () { + it('reverts when transferring from the zero address', async function () { + await expect(this.token.$_transfer(ethers.ZeroAddress, this.holder, 1n, 1n)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidSender') + .withArgs(ethers.ZeroAddress); + }); + + it('reverts when transferring to the zero address', async function () { + await expect(this.token.$_transfer(this.holder, ethers.ZeroAddress, 1n, 1n)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidReceiver') + .withArgs(ethers.ZeroAddress); + }); + }); + + describe('_burn', function () { + it('reverts with a zero from address', async function () { + await expect(this.token.$_burn(ethers.ZeroAddress, tokenId, burnValue)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidSender') + .withArgs(ethers.ZeroAddress); + }); + + describe('with burned tokens', function () { + beforeEach(async function () { + await this.token.connect(this.operator).$_mint(this.holder, tokenId, mintValue); + this.tx = await this.token.connect(this.operator).$_burn(this.holder, tokenId, burnValue); + }); + + it('emits a Transfer event to 0 address', async function () { + await expect(this.tx) + .to.emit(this.token, 'Transfer') + .withArgs(this.operator, this.holder, ethers.ZeroAddress, tokenId, burnValue); + }); + + it('debits the burned token value', async function () { + await expect(this.token.balanceOf(this.holder, tokenId)).to.eventually.be.equal(mintValue - burnValue); + }); + }); + }); + + describe('_approve', function () { + it('reverts when the owner is the zero address', async function () { + await expect(this.token.$_approve(ethers.ZeroAddress, this.recipient, 1n, 1n)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidApprover') + .withArgs(ethers.ZeroAddress); + }); + }); + + describe('_setOperator', function () { + it('reverts when the owner is the zero address', async function () { + await expect(this.token.$_setOperator(ethers.ZeroAddress, this.operator, true)) + .to.be.revertedWithCustomError(this.token, 'ERC6909InvalidApprover') + .withArgs(ethers.ZeroAddress); + }); + }); + }); +}); diff --git a/test/token/ERC6909/extensions/ERC6909ContentURI.test.js b/test/token/ERC6909/extensions/ERC6909ContentURI.test.js new file mode 100644 index 000000000..2a54e2216 --- /dev/null +++ b/test/token/ERC6909/extensions/ERC6909ContentURI.test.js @@ -0,0 +1,49 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +async function fixture() { + const token = await ethers.deployContract('$ERC6909ContentURI'); + return { token }; +} + +describe('ERC6909ContentURI', function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + describe('contractURI', function () { + it('is empty string by default', async function () { + await expect(this.token.contractURI()).to.eventually.equal(''); + }); + + it('is settable by internal setter', async function () { + await this.token.$_setContractURI('https://example.com'); + await expect(this.token.contractURI()).to.eventually.equal('https://example.com'); + }); + + it('emits an event when set', async function () { + await expect(this.token.$_setContractURI('https://example.com')).to.emit(this.token, 'ContractURIUpdated'); + }); + }); + + describe('tokenURI', function () { + it('is empty string by default', async function () { + await expect(this.token.tokenURI(1n)).to.eventually.equal(''); + }); + + it('can be set by dedicated setter', async function () { + await this.token.$_setTokenURI(1n, 'https://example.com/1'); + await expect(this.token.tokenURI(1n)).to.eventually.equal('https://example.com/1'); + + // Only set for the specified token ID + await expect(this.token.tokenURI(2n)).to.eventually.equal(''); + }); + + it('emits an event when set', async function () { + await expect(this.token.$_setTokenURI(1n, 'https://example.com/1')) + .to.emit(this.token, 'URI') + .withArgs('https://example.com/1', 1n); + }); + }); +}); diff --git a/test/token/ERC6909/extensions/ERC6909Metadata.test.js b/test/token/ERC6909/extensions/ERC6909Metadata.test.js new file mode 100644 index 000000000..e6d3dd9f3 --- /dev/null +++ b/test/token/ERC6909/extensions/ERC6909Metadata.test.js @@ -0,0 +1,58 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +async function fixture() { + const token = await ethers.deployContract('$ERC6909Metadata'); + return { token }; +} + +describe('ERC6909Metadata', function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + describe('name', function () { + it('is empty string be default', async function () { + await expect(this.token.name(1n)).to.eventually.equal(''); + }); + + it('can be set by dedicated setter', async function () { + await expect(this.token.$_setName(1n, 'My Token')) + .to.emit(this.token, 'ERC6909NameUpdated') + .withArgs(1n, 'My Token'); + await expect(this.token.name(1n)).to.eventually.equal('My Token'); + + // Only set for the specified token ID + await expect(this.token.name(2n)).to.eventually.equal(''); + }); + }); + + describe('symbol', function () { + it('is empty string be default', async function () { + await expect(this.token.symbol(1n)).to.eventually.equal(''); + }); + + it('can be set by dedicated setter', async function () { + await expect(this.token.$_setSymbol(1n, 'MTK')).to.emit(this.token, 'ERC6909SymbolUpdated').withArgs(1n, 'MTK'); + await expect(this.token.symbol(1n)).to.eventually.equal('MTK'); + + // Only set for the specified token ID + await expect(this.token.symbol(2n)).to.eventually.equal(''); + }); + }); + + describe('decimals', function () { + it('is 0 by default', async function () { + await expect(this.token.decimals(1n)).to.eventually.equal(0); + }); + + it('can be set by dedicated setter', async function () { + await expect(this.token.$_setDecimals(1n, 18)).to.emit(this.token, 'ERC6909DecimalsUpdated').withArgs(1n, 18); + await expect(this.token.decimals(1n)).to.eventually.equal(18); + + // Only set for the specified token ID + await expect(this.token.decimals(2n)).to.eventually.equal(0); + }); + }); +}); diff --git a/test/token/ERC6909/extensions/ERC6909TokenSupply.test.js b/test/token/ERC6909/extensions/ERC6909TokenSupply.test.js new file mode 100644 index 000000000..0b8b053d0 --- /dev/null +++ b/test/token/ERC6909/extensions/ERC6909TokenSupply.test.js @@ -0,0 +1,53 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +const { shouldBehaveLikeERC6909 } = require('../ERC6909.behavior'); + +async function fixture() { + const [holder, operator, recipient, other] = await ethers.getSigners(); + const token = await ethers.deployContract('$ERC6909TokenSupply'); + return { token, holder, operator, recipient, other }; +} + +describe('ERC6909TokenSupply', function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + shouldBehaveLikeERC6909(); + + describe('totalSupply', function () { + it('is zero before any mint', async function () { + await expect(this.token.totalSupply(1n)).to.eventually.be.equal(0n); + }); + + it('minting tokens increases the total supply', async function () { + await this.token.$_mint(this.holder, 1n, 17n); + await expect(this.token.totalSupply(1n)).to.eventually.be.equal(17n); + }); + + describe('with tokens minted', function () { + const supply = 1000n; + + beforeEach(async function () { + await this.token.$_mint(this.holder, 1n, supply); + }); + + it('burning tokens decreases the total supply', async function () { + await this.token.$_burn(this.holder, 1n, 17n); + await expect(this.token.totalSupply(1n)).to.eventually.be.equal(supply - 17n); + }); + + it('supply unaffected by transfers', async function () { + await this.token.$_transfer(this.holder, this.recipient, 1n, 42n); + await expect(this.token.totalSupply(1n)).to.eventually.be.equal(supply); + }); + + it('supply unaffected by no-op', async function () { + await this.token.$_update(ethers.ZeroAddress, ethers.ZeroAddress, 1n, 42n); + await expect(this.token.totalSupply(1n)).to.eventually.be.equal(supply); + }); + }); + }); +}); diff --git a/test/token/ERC721/ERC721.behavior.js b/test/token/ERC721/ERC721.behavior.js index b9dd80d6d..433ffe005 100644 --- a/test/token/ERC721/ERC721.behavior.js +++ b/test/token/ERC721/ERC721.behavior.js @@ -10,7 +10,6 @@ const firstTokenId = 5042n; const secondTokenId = 79217n; const nonExistentTokenId = 13n; const fourthTokenId = 4n; -const baseURI = 'https://api.example.com/v1/'; const RECEIVER_MAGIC_VALUE = '0x150b7a02'; @@ -936,31 +935,6 @@ function shouldBehaveLikeERC721Metadata(name, symbol) { .to.be.revertedWithCustomError(this.token, 'ERC721NonexistentToken') .withArgs(nonExistentTokenId); }); - - describe('base URI', function () { - beforeEach(function () { - if (!this.token.interface.hasFunction('setBaseURI')) { - this.skip(); - } - }); - - it('base URI can be set', async function () { - await this.token.setBaseURI(baseURI); - expect(await this.token.baseURI()).to.equal(baseURI); - }); - - it('base URI is added as a prefix to the token URI', async function () { - await this.token.setBaseURI(baseURI); - expect(await this.token.tokenURI(firstTokenId)).to.equal(baseURI + firstTokenId.toString()); - }); - - it('token URI can be changed by changing the base URI', async function () { - await this.token.setBaseURI(baseURI); - const newBaseURI = 'https://api.example.com/v2/'; - await this.token.setBaseURI(newBaseURI); - expect(await this.token.tokenURI(firstTokenId)).to.equal(newBaseURI + firstTokenId.toString()); - }); - }); }); }); } diff --git a/test/token/ERC721/extensions/ERC721Consecutive.test.js b/test/token/ERC721/extensions/ERC721Consecutive.test.js index f62d6dc5b..8d8a30378 100644 --- a/test/token/ERC721/extensions/ERC721Consecutive.test.js +++ b/test/token/ERC721/extensions/ERC721Consecutive.test.js @@ -217,14 +217,6 @@ describe('ERC721Consecutive', function () { ).to.be.revertedWithCustomError(factory, 'ERC721ForbiddenMint'); }); - it('cannot use single minting during construction', async function () { - const factory = await ethers.getContractFactory('$ERC721ConsecutiveNoConstructorMintMock'); - - await expect( - ethers.deployContract('$ERC721ConsecutiveNoConstructorMintMock', [name, symbol]), - ).to.be.revertedWithCustomError(factory, 'ERC721ForbiddenMint'); - }); - it('consecutive mint not compatible with enumerability', async function () { const factory = await ethers.getContractFactory('$ERC721ConsecutiveEnumerableMock'); diff --git a/test/utils/Arrays.t.sol b/test/utils/Arrays.t.sol index 09c7b66b6..e45d29c91 100644 --- a/test/utils/Arrays.t.sol +++ b/test/utils/Arrays.t.sol @@ -7,12 +7,12 @@ import {SymTest} from "halmos-cheatcodes/SymTest.sol"; import {Arrays} from "@openzeppelin/contracts/utils/Arrays.sol"; contract ArraysTest is Test, SymTest { - function testSort(uint256[] memory values) public { + function testSort(uint256[] memory values) public pure { Arrays.sort(values); _assertSort(values); } - function symbolicSort() public { + function symbolicSort() public pure { uint256[] memory values = new uint256[](3); for (uint256 i = 0; i < 3; i++) { values[i] = svm.createUint256("arrayElement"); @@ -23,7 +23,7 @@ contract ArraysTest is Test, SymTest { /// Asserts - function _assertSort(uint256[] memory values) internal { + function _assertSort(uint256[] memory values) internal pure { for (uint256 i = 1; i < values.length; ++i) { assertLe(values[i - 1], values[i]); } diff --git a/test/utils/Base64.t.sol b/test/utils/Base64.t.sol index 021ae03af..b8aa7ac61 100644 --- a/test/utils/Base64.t.sol +++ b/test/utils/Base64.t.sol @@ -6,11 +6,11 @@ import {Test} from "forge-std/Test.sol"; import {Base64} from "@openzeppelin/contracts/utils/Base64.sol"; contract Base64Test is Test { - function testEncode(bytes memory input) external { + function testEncode(bytes memory input) external pure { assertEq(Base64.encode(input), vm.toBase64(input)); } - function testEncodeURL(bytes memory input) external { + function testEncodeURL(bytes memory input) external pure { assertEq(Base64.encodeURL(input), _removePadding(vm.toBase64URL(input))); } diff --git a/test/utils/Calldata.test.js b/test/utils/Calldata.test.js new file mode 100644 index 000000000..7e9d3d478 --- /dev/null +++ b/test/utils/Calldata.test.js @@ -0,0 +1,22 @@ +const { ethers } = require('hardhat'); +const { expect } = require('chai'); +const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); + +async function fixture() { + const mock = await ethers.deployContract('$Calldata'); + return { mock }; +} + +describe('Calldata utilities', function () { + beforeEach(async function () { + Object.assign(this, await loadFixture(fixture)); + }); + + it('emptyBytes', async function () { + await expect(this.mock.$emptyBytes()).to.eventually.equal('0x'); + }); + + it('emptyString', async function () { + await expect(this.mock.$emptyString()).to.eventually.equal(''); + }); +}); diff --git a/test/utils/Create2.t.sol b/test/utils/Create2.t.sol index 6cc037a3b..b73db9f9a 100644 --- a/test/utils/Create2.t.sol +++ b/test/utils/Create2.t.sol @@ -6,7 +6,7 @@ import {Test} from "forge-std/Test.sol"; import {Create2} from "@openzeppelin/contracts/utils/Create2.sol"; contract Create2Test is Test { - function testSymbolicComputeAddressSpillage(bytes32 salt, bytes32 bytecodeHash, address deployer) public { + function testSymbolicComputeAddressSpillage(bytes32 salt, bytes32 bytecodeHash, address deployer) public pure { address predicted = Create2.computeAddress(salt, bytecodeHash, deployer); bytes32 spillage; assembly ("memory-safe") { diff --git a/test/utils/Nonces.behavior.js b/test/utils/Nonces.behavior.js index 32201f690..c62864ea2 100644 --- a/test/utils/Nonces.behavior.js +++ b/test/utils/Nonces.behavior.js @@ -20,39 +20,39 @@ function shouldBehaveLikeNonces() { await expect(this.mock.$_useNonce(sender)).to.emit(this.mock, eventName).withArgs(0n); - expect(this.mock.nonces(sender)).to.eventually.equal(1n); + await expect(this.mock.nonces(sender)).to.eventually.equal(1n); }); it("increments only sender's nonce", async function () { - expect(this.mock.nonces(sender)).to.eventually.equal(0n); - expect(this.mock.nonces(other)).to.eventually.equal(0n); + await expect(this.mock.nonces(sender)).to.eventually.equal(0n); + await expect(this.mock.nonces(other)).to.eventually.equal(0n); await this.mock.$_useNonce(sender); - expect(this.mock.nonces(sender)).to.eventually.equal(1n); - expect(this.mock.nonces(other)).to.eventually.equal(0n); + await expect(this.mock.nonces(sender)).to.eventually.equal(1n); + await expect(this.mock.nonces(other)).to.eventually.equal(0n); }); }); describe('_useCheckedNonce', function () { it('increments a nonce', async function () { // current nonce is 0n - expect(this.mock.nonces(sender)).to.eventually.equal(0n); + await expect(this.mock.nonces(sender)).to.eventually.equal(0n); await this.mock.$_useCheckedNonce(sender, 0n); - expect(this.mock.nonces(sender)).to.eventually.equal(1n); + await expect(this.mock.nonces(sender)).to.eventually.equal(1n); }); it("increments only sender's nonce", async function () { // current nonce is 0n - expect(this.mock.nonces(sender)).to.eventually.equal(0n); - expect(this.mock.nonces(other)).to.eventually.equal(0n); + await expect(this.mock.nonces(sender)).to.eventually.equal(0n); + await expect(this.mock.nonces(other)).to.eventually.equal(0n); await this.mock.$_useCheckedNonce(sender, 0n); - expect(this.mock.nonces(sender)).to.eventually.equal(1n); - expect(this.mock.nonces(other)).to.eventually.equal(0n); + await expect(this.mock.nonces(sender)).to.eventually.equal(1n); + await expect(this.mock.nonces(other)).to.eventually.equal(0n); }); it('reverts when nonce is not the expected', async function () { @@ -73,14 +73,14 @@ function shouldBehaveLikeNoncesKeyed() { const keyOffset = key => key << 64n; it('gets a nonce', async function () { - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); }); describe('_useNonce', function () { it('default variant uses key 0', async function () { - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); await expect(this.mock.$_useNonce(sender)).to.emit(this.mock, 'return$_useNonce_address').withArgs(0n); @@ -88,13 +88,13 @@ function shouldBehaveLikeNoncesKeyed() { .to.emit(this.mock, 'return$_useNonce_address_uint192') .withArgs(keyOffset(0n) + 1n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 2n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 2n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); }); it('use nonce at another key', async function () { - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 0n); await expect(this.mock.$_useNonce(sender, ethers.Typed.uint192(17n))) .to.emit(this.mock, 'return$_useNonce_address_uint192') @@ -104,8 +104,8 @@ function shouldBehaveLikeNoncesKeyed() { .to.emit(this.mock, 'return$_useNonce_address_uint192') .withArgs(keyOffset(17n) + 1n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 2n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(keyOffset(0n) + 0n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(keyOffset(17n) + 2n); }); }); @@ -115,7 +115,7 @@ function shouldBehaveLikeNoncesKeyed() { await this.mock.$_useCheckedNonce(sender, currentNonce); - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(currentNonce + 1n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(currentNonce + 1n); }); it('use nonce at another key', async function () { @@ -123,7 +123,7 @@ function shouldBehaveLikeNoncesKeyed() { await this.mock.$_useCheckedNonce(sender, currentNonce); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(currentNonce + 1n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(currentNonce + 1n); }); it('reverts when nonce is not the expected', async function () { @@ -152,7 +152,7 @@ function shouldBehaveLikeNoncesKeyed() { await this.mock.$_useCheckedNonce(sender, ethers.Typed.uint192(0n), currentNonce); - expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(currentNonce + 1n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(0n))).to.eventually.equal(currentNonce + 1n); }); it('use nonce at another key', async function () { @@ -160,7 +160,7 @@ function shouldBehaveLikeNoncesKeyed() { await this.mock.$_useCheckedNonce(sender, ethers.Typed.uint192(17n), currentNonce & MASK); - expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(currentNonce + 1n); + await expect(this.mock.nonces(sender, ethers.Typed.uint192(17n))).to.eventually.equal(currentNonce + 1n); }); it('reverts when nonce is not the expected', async function () { diff --git a/test/utils/ShortStrings.t.sol b/test/utils/ShortStrings.t.sol index 4aeafd721..80313bf7c 100644 --- a/test/utils/ShortStrings.t.sol +++ b/test/utils/ShortStrings.t.sol @@ -10,12 +10,12 @@ import {ShortStrings, ShortString} from "@openzeppelin/contracts/utils/ShortStri contract ShortStringsTest is Test, SymTest { string _fallback; - function testRoundtripShort(string memory input) external { + function testRoundtripShort(string memory input) external pure { vm.assume(_isShort(input)); _assertRoundtripShort(input); } - function symbolicRoundtripShort() external { + function symbolicRoundtripShort() external pure { string memory input = svm.createString(31, "RoundtripShortInput"); _assertRoundtripShort(input); } @@ -41,12 +41,12 @@ contract ShortStringsTest is Test, SymTest { _assertRevertLong(input); } - function testLengthShort(string memory input) external { + function testLengthShort(string memory input) external pure { vm.assume(_isShort(input)); _assertLengthShort(input); } - function symbolicLengthShort() external { + function symbolicLengthShort() external pure { string memory input = svm.createString(31, "LengthShortInput"); _assertLengthShort(input); } @@ -66,7 +66,7 @@ contract ShortStringsTest is Test, SymTest { /// Assertions - function _assertRoundtripShort(string memory input) internal { + function _assertRoundtripShort(string memory input) internal pure { ShortString short = ShortStrings.toShortString(input); string memory output = ShortStrings.toString(short); assertEq(input, output); @@ -84,7 +84,7 @@ contract ShortStringsTest is Test, SymTest { this.toShortString(input); } - function _assertLengthShort(string memory input) internal { + function _assertLengthShort(string memory input) internal pure { ShortString short = ShortStrings.toShortString(input); uint256 shortLength = ShortStrings.byteLength(short); uint256 inputLength = bytes(input).length; diff --git a/test/utils/SlotDerivation.t.sol b/test/utils/SlotDerivation.t.sol index 4021f0f87..a0846e332 100644 --- a/test/utils/SlotDerivation.t.sol +++ b/test/utils/SlotDerivation.t.sol @@ -42,7 +42,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(address => bytes) private _addressMapping; - function testSymbolicDeriveMappingAddress(address key) public { + function testSymbolicDeriveMappingAddress(address key) public view { bytes32 baseSlot; assembly { baseSlot := _addressMapping.slot @@ -59,7 +59,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(bool => bytes) private _boolMapping; - function testSymbolicDeriveMappingBoolean(bool key) public { + function testSymbolicDeriveMappingBoolean(bool key) public view { bytes32 baseSlot; assembly { baseSlot := _boolMapping.slot @@ -76,7 +76,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(bytes32 => bytes) private _bytes32Mapping; - function testSymbolicDeriveMappingBytes32(bytes32 key) public { + function testSymbolicDeriveMappingBytes32(bytes32 key) public view { bytes32 baseSlot; assembly { baseSlot := _bytes32Mapping.slot @@ -93,7 +93,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(bytes4 => bytes) private _bytes4Mapping; - function testSymbolicDeriveMappingBytes4(bytes4 key) public { + function testSymbolicDeriveMappingBytes4(bytes4 key) public view { bytes32 baseSlot; assembly { baseSlot := _bytes4Mapping.slot @@ -110,7 +110,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(uint256 => bytes) private _uint256Mapping; - function testSymbolicDeriveMappingUint256(uint256 key) public { + function testSymbolicDeriveMappingUint256(uint256 key) public view { bytes32 baseSlot; assembly { baseSlot := _uint256Mapping.slot @@ -127,7 +127,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(uint32 => bytes) private _uint32Mapping; - function testSymbolicDeriveMappingUint32(uint32 key) public { + function testSymbolicDeriveMappingUint32(uint32 key) public view { bytes32 baseSlot; assembly { baseSlot := _uint32Mapping.slot @@ -144,7 +144,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(int256 => bytes) private _int256Mapping; - function testSymbolicDeriveMappingInt256(int256 key) public { + function testSymbolicDeriveMappingInt256(int256 key) public view { bytes32 baseSlot; assembly { baseSlot := _int256Mapping.slot @@ -161,7 +161,7 @@ contract SlotDerivationTest is Test, SymTest { mapping(int32 => bytes) private _int32Mapping; - function testSymbolicDeriveMappingInt32(int32 key) public { + function testSymbolicDeriveMappingInt32(int32 key) public view { bytes32 baseSlot; assembly { baseSlot := _int32Mapping.slot @@ -178,15 +178,15 @@ contract SlotDerivationTest is Test, SymTest { mapping(string => bytes) private _stringMapping; - function testDeriveMappingString(string memory key) public { + function testDeriveMappingString(string memory key) public view { _assertDeriveMappingString(key); } - function symbolicDeriveMappingString() public { + function symbolicDeriveMappingString() public view { _assertDeriveMappingString(svm.createString(256, "DeriveMappingStringInput")); } - function _assertDeriveMappingString(string memory key) internal { + function _assertDeriveMappingString(string memory key) internal view { bytes32 baseSlot; assembly { baseSlot := _stringMapping.slot @@ -203,15 +203,15 @@ contract SlotDerivationTest is Test, SymTest { mapping(bytes => bytes) private _bytesMapping; - function testDeriveMappingBytes(bytes memory key) public { + function testDeriveMappingBytes(bytes memory key) public view { _assertDeriveMappingBytes(key); } - function symbolicDeriveMappingBytes() public { + function symbolicDeriveMappingBytes() public view { _assertDeriveMappingBytes(svm.createBytes(256, "DeriveMappingBytesInput")); } - function _assertDeriveMappingBytes(bytes memory key) internal { + function _assertDeriveMappingBytes(bytes memory key) internal view { bytes32 baseSlot; assembly { baseSlot := _bytesMapping.slot diff --git a/test/utils/Strings.t.sol b/test/utils/Strings.t.sol index f59e675cd..fe3c90bd1 100644 --- a/test/utils/Strings.t.sol +++ b/test/utils/Strings.t.sol @@ -9,19 +9,19 @@ import {Strings} from "@openzeppelin/contracts/utils/Strings.sol"; contract StringsTest is Test { using Strings for *; - function testParse(uint256 value) external { + function testParse(uint256 value) external pure { assertEq(value, value.toString().parseUint()); } - function testParseSigned(int256 value) external { + function testParseSigned(int256 value) external pure { assertEq(value, value.toStringSigned().parseInt()); } - function testParseHex(uint256 value) external { + function testParseHex(uint256 value) external pure { assertEq(value, value.toHexString().parseHexUint()); } - function testParseChecksumHex(address value) external { + function testParseChecksumHex(address value) external pure { assertEq(value, value.toChecksumHexString().parseAddress()); } diff --git a/test/utils/Strings.test.js b/test/utils/Strings.test.js index 0b2d87190..8d5e2401a 100644 --- a/test/utils/Strings.test.js +++ b/test/utils/Strings.test.js @@ -339,4 +339,11 @@ describe('Strings', function () { } }); }); + + describe('Escape JSON string', function () { + for (const input of ['', 'a', '{"a":"b/c"}', 'a\tb\nc\\d"e\rf/g\fh\bi']) + it(`escape ${JSON.stringify(input)}`, async function () { + await expect(this.mock.$escapeJSON(input)).to.eventually.equal(JSON.stringify(input).slice(1, -1)); + }); + }); }); diff --git a/test/utils/cryptography/MessageHashUtils.t.sol b/test/utils/cryptography/MessageHashUtils.t.sol new file mode 100644 index 000000000..4259c8839 --- /dev/null +++ b/test/utils/cryptography/MessageHashUtils.t.sol @@ -0,0 +1,33 @@ +// SPDX-License-Identifier: MIT + +pragma solidity ^0.8.20; + +import {Test} from "forge-std/Test.sol"; +import {MessageHashUtils} from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol"; + +contract MessageHashUtilsTest is Test { + function testToDataWithIntendedValidatorHash(address validator, bytes memory data) external pure { + assertEq( + MessageHashUtils.toDataWithIntendedValidatorHash(validator, data), + MessageHashUtils.toDataWithIntendedValidatorHash(_dirty(validator), data) + ); + } + + function testToDataWithIntendedValidatorHash(address validator, bytes32 messageHash) external pure { + assertEq( + MessageHashUtils.toDataWithIntendedValidatorHash(validator, messageHash), + MessageHashUtils.toDataWithIntendedValidatorHash(_dirty(validator), messageHash) + ); + + assertEq( + MessageHashUtils.toDataWithIntendedValidatorHash(validator, messageHash), + MessageHashUtils.toDataWithIntendedValidatorHash(validator, abi.encodePacked(messageHash)) + ); + } + + function _dirty(address input) private pure returns (address output) { + assembly ("memory-safe") { + output := or(input, shl(160, not(0))) + } + } +} diff --git a/test/utils/cryptography/MessageHashUtils.test.js b/test/utils/cryptography/MessageHashUtils.test.js index f20f5a3ca..57e82867e 100644 --- a/test/utils/cryptography/MessageHashUtils.test.js +++ b/test/utils/cryptography/MessageHashUtils.test.js @@ -19,14 +19,16 @@ describe('MessageHashUtils', function () { const message = ethers.randomBytes(32); const expectedHash = ethers.hashMessage(message); - expect(await this.mock.getFunction('$toEthSignedMessageHash(bytes32)')(message)).to.equal(expectedHash); + await expect(this.mock.getFunction('$toEthSignedMessageHash(bytes32)')(message)).to.eventually.equal( + expectedHash, + ); }); it('prefixes dynamic length data correctly', async function () { const message = ethers.randomBytes(128); const expectedHash = ethers.hashMessage(message); - expect(await this.mock.getFunction('$toEthSignedMessageHash(bytes)')(message)).to.equal(expectedHash); + await expect(this.mock.getFunction('$toEthSignedMessageHash(bytes)')(message)).to.eventually.equal(expectedHash); }); it('version match for bytes32', async function () { @@ -39,7 +41,20 @@ describe('MessageHashUtils', function () { }); describe('toDataWithIntendedValidatorHash', function () { - it('returns the digest correctly', async function () { + it('returns the digest of `bytes32 messageHash` correctly', async function () { + const verifier = ethers.Wallet.createRandom().address; + const message = ethers.randomBytes(32); + const expectedHash = ethers.solidityPackedKeccak256( + ['string', 'address', 'bytes32'], + ['\x19\x00', verifier, message], + ); + + await expect( + this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes32)')(verifier, message), + ).to.eventually.equal(expectedHash); + }); + + it('returns the digest of `bytes memory message` correctly', async function () { const verifier = ethers.Wallet.createRandom().address; const message = ethers.randomBytes(128); const expectedHash = ethers.solidityPackedKeccak256( @@ -47,7 +62,21 @@ describe('MessageHashUtils', function () { ['\x19\x00', verifier, message], ); - expect(await this.mock.$toDataWithIntendedValidatorHash(verifier, message)).to.equal(expectedHash); + await expect( + this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes)')(verifier, message), + ).to.eventually.equal(expectedHash); + }); + + it('version match for bytes32', async function () { + const verifier = ethers.Wallet.createRandom().address; + const message = ethers.randomBytes(32); + const fixed = await this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes)')(verifier, message); + const dynamic = await this.mock.getFunction('$toDataWithIntendedValidatorHash(address,bytes32)')( + verifier, + message, + ); + + expect(fixed).to.equal(dynamic); }); }); @@ -62,7 +91,7 @@ describe('MessageHashUtils', function () { const structhash = ethers.randomBytes(32); const expectedHash = hashTypedData(domain, structhash); - expect(await this.mock.$toTypedDataHash(domainSeparator(domain), structhash)).to.equal(expectedHash); + await expect(this.mock.$toTypedDataHash(domainSeparator(domain), structhash)).to.eventually.equal(expectedHash); }); }); }); diff --git a/test/utils/cryptography/P256.t.sol b/test/utils/cryptography/P256.t.sol index 0c9b2c78a..768f9087f 100644 --- a/test/utils/cryptography/P256.t.sol +++ b/test/utils/cryptography/P256.t.sol @@ -6,10 +6,11 @@ import {Test} from "forge-std/Test.sol"; import {P256} from "@openzeppelin/contracts/utils/cryptography/P256.sol"; import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; +import {Errors} from "@openzeppelin/contracts/utils/Errors.sol"; contract P256Test is Test { /// forge-config: default.fuzz.runs = 512 - function testVerify(bytes32 digest, uint256 seed) public { + function testVerify(bytes32 digest, uint256 seed) public view { uint256 privateKey = _asPrivateKey(seed); (uint256 x, uint256 y) = vm.publicKeyP256(privateKey); @@ -20,7 +21,7 @@ contract P256Test is Test { } /// forge-config: default.fuzz.runs = 512 - function testRecover(bytes32 digest, uint256 seed) public { + function testRecover(bytes32 digest, uint256 seed) public view { uint256 privateKey = _asPrivateKey(seed); (uint256 x, uint256 y) = vm.publicKeyP256(privateKey); @@ -31,6 +32,22 @@ contract P256Test is Test { assertTrue((qx0 == bytes32(x) && qy0 == bytes32(y)) || (qx1 == bytes32(x) && qy1 == bytes32(y))); } + function testVerifyNativeUnsupportedRIP7212(bytes32 digest, uint256 seed) public { + // By default, the precompile at address 0x100 is not supported. + + uint256 privateKey = _asPrivateKey(seed); + + (uint256 x, uint256 y) = vm.publicKeyP256(privateKey); + (bytes32 r, bytes32 s) = vm.signP256(privateKey, digest); + s = _ensureLowerS(s); + + (bool success, bytes memory returndata) = address(this).call( + abi.encodeCall(P256Test.verifyNative, (digest, r, s, bytes32(x), bytes32(y))) + ); + assertFalse(success); + assertEq(returndata, abi.encodeWithSelector(Errors.MissingPrecompile.selector, address(0x100))); + } + function _asPrivateKey(uint256 seed) private pure returns (uint256) { return bound(seed, 1, P256.N - 1); } @@ -41,4 +58,9 @@ contract P256Test is Test { return _s > P256.N / 2 ? bytes32(P256.N - _s) : s; } } + + // See https://github.com/foundry-rs/foundry/issues/10237 + function verifyNative(bytes32 digest, bytes32 r, bytes32 s, bytes32 x, bytes32 y) external view { + P256.verifyNative(digest, r, s, x, y); + } } diff --git a/test/utils/cryptography/P256.test.js b/test/utils/cryptography/P256.test.js index b9655cad3..a75d527be 100644 --- a/test/utils/cryptography/P256.test.js +++ b/test/utils/cryptography/P256.test.js @@ -44,26 +44,52 @@ describe('P256', function () { }); it('verify valid signature', async function () { - expect(await this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.be.true; - expect(await this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.be.true; - await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)) - .to.be.revertedWithCustomError(this.mock, 'MissingPrecompile') - .withArgs('0x0000000000000000000000000000000000000100'); + await expect(this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be.true; + await expect(this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .true; + await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .true; + }); + + it('verify improper signature', async function () { + const signature = this.signature; + this.signature[0] = ethers.toBeHex(N, 0x20); // r = N + await expect(this.mock.$verify(this.messageHash, ...signature, ...this.publicKey)).to.eventually.be.false; + await expect(this.mock.$verifySolidity(this.messageHash, ...signature, ...this.publicKey)).to.eventually.be.false; + await expect(this.mock.$verifyNative(this.messageHash, ...signature, ...this.publicKey)).to.eventually.be.false; }); it('recover public key', async function () { - expect(await this.mock.$recovery(this.messageHash, this.recovery, ...this.signature)).to.deep.equal( + await expect(this.mock.$recovery(this.messageHash, this.recovery, ...this.signature)).to.eventually.deep.equal( this.publicKey, ); }); + it('recovers (0,0) for invalid recovery bit', async function () { + await expect(this.mock.$recovery(this.messageHash, 2, ...this.signature)).to.eventually.deep.equal([ + ethers.ZeroHash, + ethers.ZeroHash, + ]); + }); + + it('recovers (0,0) for improper signature', async function () { + const signature = this.signature; + this.signature[0] = ethers.toBeHex(N, 0x20); // r = N + await expect(this.mock.$recovery(this.messageHash, this.recovery, ...signature)).to.eventually.deep.equal([ + ethers.ZeroHash, + ethers.ZeroHash, + ]); + }); + it('reject signature with flipped public key coordinates ([x,y] >> [y,x])', async function () { // flip public key this.publicKey.reverse(); - expect(await this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; - expect(await this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; - expect(await this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; // Flipped public key is not in the curve + await expect(this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be.false; + await expect(this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .false; + await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .false; }); it('reject signature with flipped signature values ([r,s] >> [s,r])', async function () { @@ -81,42 +107,42 @@ describe('P256', function () { ]; // Make sure it works - expect(await this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.be.true; + await expect(this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be.true; // Flip signature this.signature.reverse(); - expect(await this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; - expect(await this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; - await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)) - .to.be.revertedWithCustomError(this.mock, 'MissingPrecompile') - .withArgs('0x0000000000000000000000000000000000000100'); - expect(await this.mock.$recovery(this.messageHash, this.recovery, ...this.signature)).to.not.deep.equal( - this.publicKey, - ); + await expect(this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be.false; + await expect(this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .false; + await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .false; + await expect( + this.mock.$recovery(this.messageHash, this.recovery, ...this.signature), + ).to.eventually.not.deep.equal(this.publicKey); }); it('reject signature with invalid message hash', async function () { // random message hash this.messageHash = ethers.hexlify(ethers.randomBytes(32)); - expect(await this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; - expect(await this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.be.false; - await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)) - .to.be.revertedWithCustomError(this.mock, 'MissingPrecompile') - .withArgs('0x0000000000000000000000000000000000000100'); - expect(await this.mock.$recovery(this.messageHash, this.recovery, ...this.signature)).to.not.deep.equal( - this.publicKey, - ); + await expect(this.mock.$verify(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be.false; + await expect(this.mock.$verifySolidity(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .false; + await expect(this.mock.$verifyNative(this.messageHash, ...this.signature, ...this.publicKey)).to.eventually.be + .false; + await expect( + this.mock.$recovery(this.messageHash, this.recovery, ...this.signature), + ).to.eventually.not.deep.equal(this.publicKey); }); it('fail to recover signature with invalid recovery bit', async function () { // flip recovery bit this.recovery = 1 - this.recovery; - expect(await this.mock.$recovery(this.messageHash, this.recovery, ...this.signature)).to.not.deep.equal( - this.publicKey, - ); + await expect( + this.mock.$recovery(this.messageHash, this.recovery, ...this.signature), + ).to.eventually.not.deep.equal(this.publicKey); }); }); @@ -148,7 +174,7 @@ describe('P256', function () { const messageHash = ethers.sha256('0x' + msg); // check verify - expect(await this.mock.$verify(messageHash, r, s, x, y)).to.equal(result == 'valid'); + await expect(this.mock.$verify(messageHash, r, s, x, y)).to.eventually.equal(result == 'valid'); }); } } diff --git a/test/utils/cryptography/SignatureChecker.test.js b/test/utils/cryptography/SignatureChecker.test.js index e6a08491a..2b14f2f4c 100644 --- a/test/utils/cryptography/SignatureChecker.test.js +++ b/test/utils/cryptography/SignatureChecker.test.js @@ -2,6 +2,8 @@ const { ethers } = require('hardhat'); const { expect } = require('chai'); const { loadFixture } = require('@nomicfoundation/hardhat-network-helpers'); +const precompile = require('../../helpers/precompiles'); + const TEST_MESSAGE = ethers.id('OpenZeppelin'); const TEST_MESSAGE_HASH = ethers.hashMessage(TEST_MESSAGE); @@ -25,15 +27,18 @@ describe('SignatureChecker (ERC1271)', function () { describe('EOA account', function () { it('with matching signer and signature', async function () { - expect(await this.mock.$isValidSignatureNow(this.signer, TEST_MESSAGE_HASH, this.signature)).to.be.true; + await expect(this.mock.$isValidSignatureNow(this.signer, TEST_MESSAGE_HASH, this.signature)).to.eventually.be + .true; }); it('with invalid signer', async function () { - expect(await this.mock.$isValidSignatureNow(this.other, TEST_MESSAGE_HASH, this.signature)).to.be.false; + await expect(this.mock.$isValidSignatureNow(this.other, TEST_MESSAGE_HASH, this.signature)).to.eventually.be + .false; }); it('with invalid signature', async function () { - expect(await this.mock.$isValidSignatureNow(this.signer, WRONG_MESSAGE_HASH, this.signature)).to.be.false; + await expect(this.mock.$isValidSignatureNow(this.signer, WRONG_MESSAGE_HASH, this.signature)).to.eventually.be + .false; }); }); @@ -41,19 +46,28 @@ describe('SignatureChecker (ERC1271)', function () { for (const fn of ['isValidERC1271SignatureNow', 'isValidSignatureNow']) { describe(fn, function () { it('with matching signer and signature', async function () { - expect(await this.mock.getFunction(`$${fn}`)(this.wallet, TEST_MESSAGE_HASH, this.signature)).to.be.true; + await expect(this.mock.getFunction(`$${fn}`)(this.wallet, TEST_MESSAGE_HASH, this.signature)).to.eventually.be + .true; }); it('with invalid signer', async function () { - expect(await this.mock.getFunction(`$${fn}`)(this.mock, TEST_MESSAGE_HASH, this.signature)).to.be.false; + await expect(this.mock.getFunction(`$${fn}`)(this.mock, TEST_MESSAGE_HASH, this.signature)).to.eventually.be + .false; + }); + + it('with identity precompile', async function () { + await expect(this.mock.getFunction(`$${fn}`)(precompile.identity, TEST_MESSAGE_HASH, this.signature)).to + .eventually.be.false; }); it('with invalid signature', async function () { - expect(await this.mock.getFunction(`$${fn}`)(this.wallet, WRONG_MESSAGE_HASH, this.signature)).to.be.false; + await expect(this.mock.getFunction(`$${fn}`)(this.wallet, WRONG_MESSAGE_HASH, this.signature)).to.eventually + .be.false; }); it('with malicious wallet', async function () { - expect(await this.mock.getFunction(`$${fn}`)(this.malicious, TEST_MESSAGE_HASH, this.signature)).to.be.false; + await expect(this.mock.getFunction(`$${fn}`)(this.malicious, TEST_MESSAGE_HASH, this.signature)).to.eventually + .be.false; }); }); } diff --git a/test/utils/introspection/SupportsInterface.behavior.js b/test/utils/introspection/SupportsInterface.behavior.js index 8a7bc4b5e..6e716d130 100644 --- a/test/utils/introspection/SupportsInterface.behavior.js +++ b/test/utils/introspection/SupportsInterface.behavior.js @@ -3,6 +3,34 @@ const { interfaceId } = require('../../helpers/methods'); const { mapValues } = require('../../helpers/iterate'); const INVALID_ID = '0xffffffff'; +const GOVERNOR_INTERFACE = [ + 'name()', + 'version()', + 'COUNTING_MODE()', + 'hashProposal(address[],uint256[],bytes[],bytes32)', + 'state(uint256)', + 'proposalThreshold()', + 'proposalSnapshot(uint256)', + 'proposalDeadline(uint256)', + 'proposalProposer(uint256)', + 'proposalEta(uint256)', + 'proposalNeedsQueuing(uint256)', + 'votingDelay()', + 'votingPeriod()', + 'quorum(uint256)', + 'getVotes(address,uint256)', + 'getVotesWithParams(address,uint256,bytes)', + 'hasVoted(uint256,address)', + 'propose(address[],uint256[],bytes[],string)', + 'queue(address[],uint256[],bytes[],bytes32)', + 'execute(address[],uint256[],bytes[],bytes32)', + 'cancel(address[],uint256[],bytes[],bytes32)', + 'castVote(uint256,uint8)', + 'castVoteWithReason(uint256,uint8,string)', + 'castVoteWithReasonAndParams(uint256,uint8,string,bytes)', + 'castVoteBySig(uint256,uint8,address,bytes)', + 'castVoteWithReasonAndParamsBySig(uint256,uint8,address,string,bytes,bytes)', +]; const SIGNATURES = { ERC165: ['supportsInterface(bytes4)'], ERC721: [ @@ -59,41 +87,32 @@ const SIGNATURES = { 'acceptDefaultAdminTransfer()', 'cancelDefaultAdminTransfer()', ], - Governor: [ - 'name()', - 'version()', - 'COUNTING_MODE()', - 'hashProposal(address[],uint256[],bytes[],bytes32)', - 'state(uint256)', - 'proposalThreshold()', - 'proposalSnapshot(uint256)', - 'proposalDeadline(uint256)', - 'proposalProposer(uint256)', - 'proposalEta(uint256)', - 'proposalNeedsQueuing(uint256)', - 'votingDelay()', - 'votingPeriod()', - 'quorum(uint256)', - 'getVotes(address,uint256)', - 'getVotesWithParams(address,uint256,bytes)', - 'hasVoted(uint256,address)', - 'propose(address[],uint256[],bytes[],string)', - 'queue(address[],uint256[],bytes[],bytes32)', - 'execute(address[],uint256[],bytes[],bytes32)', - 'cancel(address[],uint256[],bytes[],bytes32)', - 'castVote(uint256,uint8)', - 'castVoteWithReason(uint256,uint8,string)', - 'castVoteWithReasonAndParams(uint256,uint8,string,bytes)', - 'castVoteBySig(uint256,uint8,address,bytes)', - 'castVoteWithReasonAndParamsBySig(uint256,uint8,address,string,bytes,bytes)', - ], + Governor: GOVERNOR_INTERFACE, + Governor_5_3: GOVERNOR_INTERFACE.concat('getProposalId(address[],uint256[],bytes[],bytes32)'), ERC2981: ['royaltyInfo(uint256,uint256)'], + ERC6909: [ + 'balanceOf(address,uint256)', + 'allowance(address,address,uint256)', + 'isOperator(address,address)', + 'transfer(address,uint256,uint256)', + 'transferFrom(address,address,uint256,uint256)', + 'approve(address,uint256,uint256)', + 'setOperator(address,bool)', + ], }; const INTERFACE_IDS = mapValues(SIGNATURES, interfaceId); -function shouldSupportInterfaces(interfaces = []) { +function shouldSupportInterfaces(interfaces = [], signatures = SIGNATURES) { + // case where only signatures are provided + if (!Array.isArray(interfaces)) { + signatures = interfaces; + interfaces = Object.keys(interfaces); + } + interfaces.unshift('ERC165'); + signatures.ERC165 = SIGNATURES.ERC165; + const interfaceIds = mapValues(signatures, interfaceId, ([name]) => interfaces.includes(name)); describe('ERC165', function () { beforeEach(function () { @@ -103,14 +122,14 @@ function shouldSupportInterfaces(interfaces = []) { describe('when the interfaceId is supported', function () { it('uses less than 30k gas', async function () { for (const k of interfaces) { - const interfaceId = INTERFACE_IDS[k] ?? k; + const interfaceId = interfaceIds[k] ?? k; expect(await this.contractUnderTest.supportsInterface.estimateGas(interfaceId)).to.lte(30_000n); } }); it('returns true', async function () { for (const k of interfaces) { - const interfaceId = INTERFACE_IDS[k] ?? k; + const interfaceId = interfaceIds[k] ?? k; expect(await this.contractUnderTest.supportsInterface(interfaceId), `does not support ${k}`).to.be.true; } }); @@ -129,10 +148,10 @@ function shouldSupportInterfaces(interfaces = []) { it('all interface functions are in ABI', async function () { for (const k of interfaces) { // skip interfaces for which we don't have a function list - if (SIGNATURES[k] === undefined) continue; + if (signatures[k] === undefined) continue; // Check the presence of each function in the contract's interface - for (const fnSig of SIGNATURES[k]) { + for (const fnSig of signatures[k]) { expect(this.contractUnderTest.interface.hasFunction(fnSig), `did not find ${fnSig}`).to.be.true; } } @@ -141,5 +160,7 @@ function shouldSupportInterfaces(interfaces = []) { } module.exports = { + SIGNATURES, + INTERFACE_IDS, shouldSupportInterfaces, }; diff --git a/test/utils/math/Math.t.sol b/test/utils/math/Math.t.sol index 3d4932eea..3c83febe9 100644 --- a/test/utils/math/Math.t.sol +++ b/test/utils/math/Math.t.sol @@ -7,18 +7,60 @@ import {Test, stdError} from "forge-std/Test.sol"; import {Math} from "@openzeppelin/contracts/utils/math/Math.sol"; contract MathTest is Test { - function testSymbolicTernary(bool f, uint256 a, uint256 b) public { + function testSymbolicTernary(bool f, uint256 a, uint256 b) public pure { assertEq(Math.ternary(f, a, b), f ? a : b); } + // ADD512 & MUL512 + function testAdd512(uint256 a, uint256 b) public pure { + (uint256 high, uint256 low) = Math.add512(a, b); + + // test against tryAdd + (bool success, uint256 result) = Math.tryAdd(a, b); + if (success) { + assertEq(high, 0); + assertEq(low, result); + } else { + assertEq(high, 1); + } + + // test against unchecked + unchecked { + assertEq(low, a + b); // unchecked allow overflow + } + } + + function testMul512(uint256 a, uint256 b) public pure { + (uint256 high, uint256 low) = Math.mul512(a, b); + + // test against tryMul + (bool success, uint256 result) = Math.tryMul(a, b); + if (success) { + assertEq(high, 0); + assertEq(low, result); + } else { + assertGt(high, 0); + } + + // test against unchecked + unchecked { + assertEq(low, a * b); // unchecked allow overflow + } + + // test against alternative method + (uint256 _high, uint256 _low) = _mulKaratsuba(a, b); + assertEq(high, _high); + assertEq(low, _low); + } + // MIN & MAX - function testSymbolicMinMax(uint256 a, uint256 b) public { + function testSymbolicMinMax(uint256 a, uint256 b) public pure { assertEq(Math.min(a, b), a < b ? a : b); assertEq(Math.max(a, b), a > b ? a : b); } // CEILDIV - function testCeilDiv(uint256 a, uint256 b) public { + function testCeilDiv(uint256 a, uint256 b) public pure { vm.assume(b > 0); uint256 result = Math.ceilDiv(a, b); @@ -35,7 +77,7 @@ contract MathTest is Test { } // SQRT - function testSqrt(uint256 input, uint8 r) public { + function testSqrt(uint256 input, uint8 r) public pure { Math.Rounding rounding = _asRounding(r); uint256 result = Math.sqrt(input, rounding); @@ -66,31 +108,31 @@ contract MathTest is Test { } // INV - function testInvMod(uint256 value, uint256 p) public { + function testInvMod(uint256 value, uint256 p) public pure { _testInvMod(value, p, true); } - function testInvMod2(uint256 seed) public { + function testInvMod2(uint256 seed) public pure { uint256 p = 2; // prime _testInvMod(bound(seed, 1, p - 1), p, false); } - function testInvMod17(uint256 seed) public { + function testInvMod17(uint256 seed) public pure { uint256 p = 17; // prime _testInvMod(bound(seed, 1, p - 1), p, false); } - function testInvMod65537(uint256 seed) public { + function testInvMod65537(uint256 seed) public pure { uint256 p = 65537; // prime _testInvMod(bound(seed, 1, p - 1), p, false); } - function testInvModP256(uint256 seed) public { + function testInvModP256(uint256 seed) public pure { uint256 p = 0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff; // prime _testInvMod(bound(seed, 1, p - 1), p, false); } - function _testInvMod(uint256 value, uint256 p, bool allowZero) private { + function _testInvMod(uint256 value, uint256 p, bool allowZero) private pure { uint256 inverse = Math.invMod(value, p); if (inverse != 0) { assertEq(mulmod(value, inverse, p), 1); @@ -101,7 +143,7 @@ contract MathTest is Test { } // LOG2 - function testLog2(uint256 input, uint8 r) public { + function testLog2(uint256 input, uint8 r) public pure { Math.Rounding rounding = _asRounding(r); uint256 result = Math.log2(input, rounding); @@ -128,7 +170,7 @@ contract MathTest is Test { } // LOG10 - function testLog10(uint256 input, uint8 r) public { + function testLog10(uint256 input, uint8 r) public pure { Math.Rounding rounding = _asRounding(r); uint256 result = Math.log10(input, rounding); @@ -155,7 +197,7 @@ contract MathTest is Test { } // LOG256 - function testLog256(uint256 input, uint8 r) public { + function testLog256(uint256 input, uint8 r) public pure { Math.Rounding rounding = _asRounding(r); uint256 result = Math.log256(input, rounding); @@ -182,9 +224,9 @@ contract MathTest is Test { } // MULDIV - function testMulDiv(uint256 x, uint256 y, uint256 d) public { + function testMulDiv(uint256 x, uint256 y, uint256 d) public pure { // Full precision for x * y - (uint256 xyHi, uint256 xyLo) = _mulHighLow(x, y); + (uint256 xyHi, uint256 xyLo) = Math.mul512(x, y); // Assume result won't overflow (see {testMulDivDomain}) // This also checks that `d` is positive @@ -194,9 +236,9 @@ contract MathTest is Test { uint256 q = Math.mulDiv(x, y, d); // Full precision for q * d - (uint256 qdHi, uint256 qdLo) = _mulHighLow(q, d); + (uint256 qdHi, uint256 qdLo) = Math.mul512(q, d); // Add remainder of x * y / d (computed as rem = (x * y % d)) - (uint256 qdRemLo, uint256 c) = _addCarry(qdLo, mulmod(x, y, d)); + (uint256 c, uint256 qdRemLo) = Math.add512(qdLo, mulmod(x, y, d)); uint256 qdRemHi = qdHi + c; // Full precision check that x * y = q * d + rem @@ -204,8 +246,9 @@ contract MathTest is Test { assertEq(xyLo, qdRemLo); } + /// forge-config: default.allow_internal_expect_revert = true function testMulDivDomain(uint256 x, uint256 y, uint256 d) public { - (uint256 xyHi, ) = _mulHighLow(x, y); + (uint256 xyHi, ) = Math.mul512(x, y); // Violate {testMulDiv} assumption (covers d is 0 and result overflow) vm.assume(xyHi >= d); @@ -216,6 +259,7 @@ contract MathTest is Test { } // MOD EXP + /// forge-config: default.allow_internal_expect_revert = true function testModExp(uint256 b, uint256 e, uint256 m) public { if (m == 0) { vm.expectRevert(stdError.divisionError); @@ -225,7 +269,7 @@ contract MathTest is Test { assertEq(result, _nativeModExp(b, e, m)); } - function testTryModExp(uint256 b, uint256 e, uint256 m) public { + function testTryModExp(uint256 b, uint256 e, uint256 m) public view { (bool success, uint256 result) = Math.tryModExp(b, e, m); assertEq(success, m != 0); if (success) { @@ -236,6 +280,7 @@ contract MathTest is Test { } } + /// forge-config: default.allow_internal_expect_revert = true function testModExpMemory(uint256 b, uint256 e, uint256 m) public { if (m == 0) { vm.expectRevert(stdError.divisionError); @@ -247,7 +292,7 @@ contract MathTest is Test { assertEq(res, _nativeModExp(b, e, m)); } - function testTryModExpMemory(uint256 b, uint256 e, uint256 m) public { + function testTryModExpMemory(uint256 b, uint256 e, uint256 m) public view { (bool success, bytes memory result) = Math.tryModExp( abi.encodePacked(b), abi.encodePacked(e), @@ -263,26 +308,13 @@ contract MathTest is Test { } } - function _nativeModExp(uint256 b, uint256 e, uint256 m) private pure returns (uint256) { - if (m == 1) return 0; - uint256 r = 1; - while (e > 0) { - if (e % 2 > 0) { - r = mulmod(r, b, m); - } - b = mulmod(b, b, m); - e >>= 1; - } - return r; - } - // Helpers function _asRounding(uint8 r) private pure returns (Math.Rounding) { vm.assume(r < uint8(type(Math.Rounding).max)); return Math.Rounding(r); } - function _mulHighLow(uint256 x, uint256 y) private pure returns (uint256 high, uint256 low) { + function _mulKaratsuba(uint256 x, uint256 y) private pure returns (uint256 high, uint256 low) { (uint256 x0, uint256 x1) = (x & type(uint128).max, x >> 128); (uint256 y0, uint256 y1) = (y & type(uint128).max, y >> 128); @@ -302,10 +334,16 @@ contract MathTest is Test { } } - function _addCarry(uint256 x, uint256 y) private pure returns (uint256 res, uint256 carry) { - unchecked { - res = x + y; + function _nativeModExp(uint256 b, uint256 e, uint256 m) private pure returns (uint256) { + if (m == 1) return 0; + uint256 r = 1; + while (e > 0) { + if (e % 2 > 0) { + r = mulmod(r, b, m); + } + b = mulmod(b, b, m); + e >>= 1; } - carry = res < x ? 1 : 0; + return r; } } diff --git a/test/utils/math/Math.test.js b/test/utils/math/Math.test.js index f38f2f318..6a0993814 100644 --- a/test/utils/math/Math.test.js +++ b/test/utils/math/Math.test.js @@ -16,10 +16,13 @@ const uint256 = value => ethers.Typed.uint256(value); bytes.zero = '0x'; uint256.zero = 0n; -async function testCommutative(fn, lhs, rhs, expected, ...extra) { - expect(await fn(lhs, rhs, ...extra)).to.deep.equal(expected); - expect(await fn(rhs, lhs, ...extra)).to.deep.equal(expected); -} +const testCommutative = (fn, lhs, rhs, expected, ...extra) => + Promise.all([ + expect(fn(lhs, rhs, ...extra)).to.eventually.deep.equal(expected), + expect(fn(rhs, lhs, ...extra)).to.eventually.deep.equal(expected), + ]); + +const splitHighLow = n => [n / (1n << 256n), n % (1n << 256n)]; async function fixture() { const mock = await ethers.deployContract('$Math'); @@ -39,6 +42,24 @@ describe('Math', function () { Object.assign(this, await loadFixture(fixture)); }); + describe('add512', function () { + it('adds correctly without reverting', async function () { + const values = [0n, 1n, 17n, 42n, ethers.MaxUint256 - 1n, ethers.MaxUint256]; + for (const [a, b] of product(values, values)) { + await expect(this.mock.$add512(a, b)).to.eventually.deep.equal(splitHighLow(a + b)); + } + }); + }); + + describe('mul512', function () { + it('multiplies correctly without reverting', async function () { + const values = [0n, 1n, 17n, 42n, ethers.MaxUint256 - 1n, ethers.MaxUint256]; + for (const [a, b] of product(values, values)) { + await expect(this.mock.$mul512(a, b)).to.eventually.deep.equal(splitHighLow(a * b)); + } + }); + }); + describe('tryAdd', function () { it('adds correctly', async function () { const a = 5678n; @@ -57,13 +78,13 @@ describe('Math', function () { it('subtracts correctly', async function () { const a = 5678n; const b = 1234n; - expect(await this.mock.$trySub(a, b)).to.deep.equal([true, a - b]); + await expect(this.mock.$trySub(a, b)).to.eventually.deep.equal([true, a - b]); }); it('reverts if subtraction result would be negative', async function () { const a = 1234n; const b = 5678n; - expect(await this.mock.$trySub(a, b)).to.deep.equal([false, 0n]); + await expect(this.mock.$trySub(a, b)).to.eventually.deep.equal([false, 0n]); }); }); @@ -91,25 +112,25 @@ describe('Math', function () { it('divides correctly', async function () { const a = 5678n; const b = 5678n; - expect(await this.mock.$tryDiv(a, b)).to.deep.equal([true, a / b]); + await expect(this.mock.$tryDiv(a, b)).to.eventually.deep.equal([true, a / b]); }); it('divides zero correctly', async function () { const a = 0n; const b = 5678n; - expect(await this.mock.$tryDiv(a, b)).to.deep.equal([true, a / b]); + await expect(this.mock.$tryDiv(a, b)).to.eventually.deep.equal([true, a / b]); }); it('returns complete number result on non-even division', async function () { const a = 7000n; const b = 5678n; - expect(await this.mock.$tryDiv(a, b)).to.deep.equal([true, a / b]); + await expect(this.mock.$tryDiv(a, b)).to.eventually.deep.equal([true, a / b]); }); it('reverts on division by zero', async function () { const a = 5678n; const b = 0n; - expect(await this.mock.$tryDiv(a, b)).to.deep.equal([false, 0n]); + await expect(this.mock.$tryDiv(a, b)).to.eventually.deep.equal([false, 0n]); }); }); @@ -118,32 +139,88 @@ describe('Math', function () { it('when the dividend is smaller than the divisor', async function () { const a = 284n; const b = 5678n; - expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]); + await expect(this.mock.$tryMod(a, b)).to.eventually.deep.equal([true, a % b]); }); it('when the dividend is equal to the divisor', async function () { const a = 5678n; const b = 5678n; - expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]); + await expect(this.mock.$tryMod(a, b)).to.eventually.deep.equal([true, a % b]); }); it('when the dividend is larger than the divisor', async function () { const a = 7000n; const b = 5678n; - expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]); + await expect(this.mock.$tryMod(a, b)).to.eventually.deep.equal([true, a % b]); }); it('when the dividend is a multiple of the divisor', async function () { const a = 17034n; // 17034 == 5678 * 3 const b = 5678n; - expect(await this.mock.$tryMod(a, b)).to.deep.equal([true, a % b]); + await expect(this.mock.$tryMod(a, b)).to.eventually.deep.equal([true, a % b]); }); }); it('reverts with a 0 divisor', async function () { const a = 5678n; const b = 0n; - expect(await this.mock.$tryMod(a, b)).to.deep.equal([false, 0n]); + await expect(this.mock.$tryMod(a, b)).to.eventually.deep.equal([false, 0n]); + }); + }); + + describe('saturatingAdd', function () { + it('adds correctly', async function () { + const a = 5678n; + const b = 1234n; + await testCommutative(this.mock.$saturatingAdd, a, b, a + b); + await testCommutative(this.mock.$saturatingAdd, a, 0n, a); + await testCommutative(this.mock.$saturatingAdd, ethers.MaxUint256, 0n, ethers.MaxUint256); + }); + + it('bounds on addition overflow', async function () { + await testCommutative(this.mock.$saturatingAdd, ethers.MaxUint256, 1n, ethers.MaxUint256); + await expect(this.mock.$saturatingAdd(ethers.MaxUint256, ethers.MaxUint256)).to.eventually.equal( + ethers.MaxUint256, + ); + }); + }); + + describe('saturatingSub', function () { + it('subtracts correctly', async function () { + const a = 5678n; + const b = 1234n; + await expect(this.mock.$saturatingSub(a, b)).to.eventually.equal(a - b); + await expect(this.mock.$saturatingSub(a, a)).to.eventually.equal(0n); + await expect(this.mock.$saturatingSub(a, 0n)).to.eventually.equal(a); + await expect(this.mock.$saturatingSub(0n, a)).to.eventually.equal(0n); + await expect(this.mock.$saturatingSub(ethers.MaxUint256, 1n)).to.eventually.equal(ethers.MaxUint256 - 1n); + }); + + it('bounds on subtraction overflow', async function () { + await expect(this.mock.$saturatingSub(0n, 1n)).to.eventually.equal(0n); + await expect(this.mock.$saturatingSub(1n, 2n)).to.eventually.equal(0n); + await expect(this.mock.$saturatingSub(1n, ethers.MaxUint256)).to.eventually.equal(0n); + await expect(this.mock.$saturatingSub(ethers.MaxUint256 - 1n, ethers.MaxUint256)).to.eventually.equal(0n); + }); + }); + + describe('saturatingMul', function () { + it('multiplies correctly', async function () { + const a = 1234n; + const b = 5678n; + await testCommutative(this.mock.$saturatingMul, a, b, a * b); + }); + + it('multiplies by zero correctly', async function () { + const a = 0n; + const b = 5678n; + await testCommutative(this.mock.$saturatingMul, a, b, 0n); + }); + + it('bounds on multiplication overflow', async function () { + const a = ethers.MaxUint256; + const b = 2n; + await testCommutative(this.mock.$saturatingMul, a, b, ethers.MaxUint256); }); }); @@ -163,24 +240,24 @@ describe('Math', function () { it('is correctly calculated with two odd numbers', async function () { const a = 57417n; const b = 95431n; - expect(await this.mock.$average(a, b)).to.equal((a + b) / 2n); + await expect(this.mock.$average(a, b)).to.eventually.equal((a + b) / 2n); }); it('is correctly calculated with two even numbers', async function () { const a = 42304n; const b = 84346n; - expect(await this.mock.$average(a, b)).to.equal((a + b) / 2n); + await expect(this.mock.$average(a, b)).to.eventually.equal((a + b) / 2n); }); it('is correctly calculated with one even and one odd number', async function () { const a = 57417n; const b = 84346n; - expect(await this.mock.$average(a, b)).to.equal((a + b) / 2n); + await expect(this.mock.$average(a, b)).to.eventually.equal((a + b) / 2n); }); it('is correctly calculated with two max uint256 numbers', async function () { const a = ethers.MaxUint256; - expect(await this.mock.$average(a, a)).to.equal(a); + await expect(this.mock.$average(a, a)).to.eventually.equal(a); }); }); @@ -196,35 +273,35 @@ describe('Math', function () { const a = 0n; const b = 2n; const r = 0n; - expect(await this.mock.$ceilDiv(a, b)).to.equal(r); + await expect(this.mock.$ceilDiv(a, b)).to.eventually.equal(r); }); it('does not round up on exact division', async function () { const a = 10n; const b = 5n; const r = 2n; - expect(await this.mock.$ceilDiv(a, b)).to.equal(r); + await expect(this.mock.$ceilDiv(a, b)).to.eventually.equal(r); }); it('rounds up on division with remainders', async function () { const a = 42n; const b = 13n; const r = 4n; - expect(await this.mock.$ceilDiv(a, b)).to.equal(r); + await expect(this.mock.$ceilDiv(a, b)).to.eventually.equal(r); }); it('does not overflow', async function () { const a = ethers.MaxUint256; const b = 2n; const r = 1n << 255n; - expect(await this.mock.$ceilDiv(a, b)).to.equal(r); + await expect(this.mock.$ceilDiv(a, b)).to.eventually.equal(r); }); it('correctly computes max uint256 divided by 1', async function () { const a = ethers.MaxUint256; const b = 1n; const r = ethers.MaxUint256; - expect(await this.mock.$ceilDiv(a, b)).to.equal(r); + await expect(this.mock.$ceilDiv(a, b)).to.eventually.equal(r); }); }); @@ -248,28 +325,97 @@ describe('Math', function () { describe('does round down', function () { it('small values', async function () { for (const rounding of RoundingDown) { - expect(await this.mock.$mulDiv(3n, 4n, 5n, rounding)).to.equal(2n); - expect(await this.mock.$mulDiv(3n, 5n, 5n, rounding)).to.equal(3n); + await expect(this.mock.$mulDiv(3n, 4n, 5n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$mulDiv(3n, 5n, 5n, rounding)).to.eventually.equal(3n); } }); it('large values', async function () { for (const rounding of RoundingDown) { - expect(await this.mock.$mulDiv(42n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding)).to.equal(41n); + await expect(this.mock.$mulDiv(42n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding)).to.eventually.equal( + 41n, + ); - expect(await this.mock.$mulDiv(17n, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal(17n); + await expect(this.mock.$mulDiv(17n, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.eventually.equal(17n); - expect( - await this.mock.$mulDiv(ethers.MaxUint256 - 1n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), - ).to.equal(ethers.MaxUint256 - 2n); + await expect( + this.mock.$mulDiv(ethers.MaxUint256 - 1n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), + ).to.eventually.equal(ethers.MaxUint256 - 2n); - expect( - await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), - ).to.equal(ethers.MaxUint256 - 1n); + await expect( + this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), + ).to.eventually.equal(ethers.MaxUint256 - 1n); - expect(await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal( + await expect( + this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256, ethers.MaxUint256, rounding), + ).to.eventually.equal(ethers.MaxUint256); + } + }); + }); + + describe('does round up', function () { + it('small values', async function () { + for (const rounding of RoundingUp) { + await expect(this.mock.$mulDiv(3n, 4n, 5n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$mulDiv(3n, 5n, 5n, rounding)).to.eventually.equal(3n); + } + }); + + it('large values', async function () { + for (const rounding of RoundingUp) { + await expect(this.mock.$mulDiv(42n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding)).to.eventually.equal( + 42n, + ); + + await expect(this.mock.$mulDiv(17n, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.eventually.equal(17n); + + await expect( + this.mock.$mulDiv(ethers.MaxUint256 - 1n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), + ).to.eventually.equal(ethers.MaxUint256 - 1n); + + await expect( + this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), + ).to.eventually.equal(ethers.MaxUint256 - 1n); + + await expect( + this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256, ethers.MaxUint256, rounding), + ).to.eventually.equal(ethers.MaxUint256); + } + }); + }); + }); + + describe('mulShr', function () { + it('reverts with result higher than 2 ^ 256', async function () { + const a = 5n; + const b = ethers.MaxUint256; + const c = 1n; + await expect(this.mock.$mulShr(a, b, c, Rounding.Floor)).to.be.revertedWithPanic( + PANIC_CODES.ARITHMETIC_UNDER_OR_OVERFLOW, + ); + }); + + describe('does round down', function () { + it('small values', async function () { + for (const rounding of RoundingDown) { + await expect(this.mock.$mulShr(3n, 5n, 1n, rounding)).to.eventually.equal(7n); + await expect(this.mock.$mulShr(3n, 5n, 2n, rounding)).to.eventually.equal(3n); + } + }); + + it('large values', async function () { + for (const rounding of RoundingDown) { + await expect(this.mock.$mulShr(42n, ethers.MaxUint256, 255n, rounding)).to.eventually.equal(83n); + + await expect(this.mock.$mulShr(17n, ethers.MaxUint256, 255n, rounding)).to.eventually.equal(33n); + + await expect(this.mock.$mulShr(ethers.MaxUint256, ethers.MaxInt256 + 1n, 255n, rounding)).to.eventually.equal( ethers.MaxUint256, ); + + await expect(this.mock.$mulShr(ethers.MaxUint256, ethers.MaxInt256, 255n, rounding)).to.eventually.equal( + ethers.MaxUint256 - 2n, + ); } }); }); @@ -277,28 +423,24 @@ describe('Math', function () { describe('does round up', function () { it('small values', async function () { for (const rounding of RoundingUp) { - expect(await this.mock.$mulDiv(3n, 4n, 5n, rounding)).to.equal(3n); - expect(await this.mock.$mulDiv(3n, 5n, 5n, rounding)).to.equal(3n); + await expect(this.mock.$mulShr(3n, 5n, 1n, rounding)).to.eventually.equal(8n); + await expect(this.mock.$mulShr(3n, 5n, 2n, rounding)).to.eventually.equal(4n); } }); it('large values', async function () { for (const rounding of RoundingUp) { - expect(await this.mock.$mulDiv(42n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding)).to.equal(42n); + await expect(this.mock.$mulShr(42n, ethers.MaxUint256, 255n, rounding)).to.eventually.equal(84n); - expect(await this.mock.$mulDiv(17n, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal(17n); + await expect(this.mock.$mulShr(17n, ethers.MaxUint256, 255n, rounding)).to.eventually.equal(34n); - expect( - await this.mock.$mulDiv(ethers.MaxUint256 - 1n, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), - ).to.equal(ethers.MaxUint256 - 1n); - - expect( - await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256 - 1n, ethers.MaxUint256, rounding), - ).to.equal(ethers.MaxUint256 - 1n); - - expect(await this.mock.$mulDiv(ethers.MaxUint256, ethers.MaxUint256, ethers.MaxUint256, rounding)).to.equal( + await expect(this.mock.$mulShr(ethers.MaxUint256, ethers.MaxInt256 + 1n, 255n, rounding)).to.eventually.equal( ethers.MaxUint256, ); + + await expect(this.mock.$mulShr(ethers.MaxUint256, ethers.MaxInt256, 255n, rounding)).to.eventually.equal( + ethers.MaxUint256 - 1n, + ); } }); }); @@ -320,8 +462,8 @@ describe('Math', function () { describe(`using p=${p} which is ${p > 1 && factors.length > 1 ? 'not ' : ''}a prime`, function () { it('trying to inverse 0 returns 0', async function () { - expect(await this.mock.$invMod(0, p)).to.equal(0n); - expect(await this.mock.$invMod(p, p)).to.equal(0n); // p is 0 mod p + await expect(this.mock.$invMod(0, p)).to.eventually.equal(0n); + await expect(this.mock.$invMod(p, p)).to.eventually.equal(0n); // p is 0 mod p }); if (p != 0) { @@ -349,7 +491,7 @@ describe('Math', function () { const e = 200n; const m = 50n; - expect(await this.mock.$modExp(type(b), type(e), type(m))).to.equal(type(b ** e % m).value); + await expect(this.mock.$modExp(type(b), type(e), type(m))).to.eventually.equal(type(b ** e % m).value); }); it('is correctly reverting when modulus is zero', async function () { @@ -373,7 +515,9 @@ describe('Math', function () { it(`calculates b ** e % m (b=2**${log2b}+1) (e=2**${log2e}+1) (m=2**${log2m}+1)`, async function () { const mLength = ethers.dataLength(ethers.toBeHex(m)); - expect(await this.mock.$modExp(bytes(b), bytes(e), bytes(m))).to.equal(bytes(modExp(b, e, m), mLength).value); + await expect(this.mock.$modExp(bytes(b), bytes(e), bytes(m))).to.eventually.equal( + bytes(modExp(b, e, m), mLength).value, + ); }); } }); @@ -387,7 +531,10 @@ describe('Math', function () { const e = 200n; const m = 50n; - expect(await this.mock.$tryModExp(type(b), type(e), type(m))).to.deep.equal([true, type(b ** e % m).value]); + await expect(this.mock.$tryModExp(type(b), type(e), type(m))).to.eventually.deep.equal([ + true, + type(b ** e % m).value, + ]); }); it('is correctly reverting when modulus is zero', async function () { @@ -395,7 +542,7 @@ describe('Math', function () { const e = 200n; const m = 0n; - expect(await this.mock.$tryModExp(type(b), type(e), type(m))).to.deep.equal([false, type.zero]); + await expect(this.mock.$tryModExp(type(b), type(e), type(m))).to.eventually.deep.equal([false, type.zero]); }); }); } @@ -409,7 +556,7 @@ describe('Math', function () { it(`calculates b ** e % m (b=2**${log2b}+1) (e=2**${log2e}+1) (m=2**${log2m}+1)`, async function () { const mLength = ethers.dataLength(ethers.toBeHex(m)); - expect(await this.mock.$tryModExp(bytes(b), bytes(e), bytes(m))).to.deep.equal([ + await expect(this.mock.$tryModExp(bytes(b), bytes(e), bytes(m))).to.eventually.deep.equal([ true, bytes(modExp(b, e, m), mLength).value, ]); @@ -421,35 +568,39 @@ describe('Math', function () { describe('sqrt', function () { it('rounds down', async function () { for (const rounding of RoundingDown) { - expect(await this.mock.$sqrt(0n, rounding)).to.equal(0n); - expect(await this.mock.$sqrt(1n, rounding)).to.equal(1n); - expect(await this.mock.$sqrt(2n, rounding)).to.equal(1n); - expect(await this.mock.$sqrt(3n, rounding)).to.equal(1n); - expect(await this.mock.$sqrt(4n, rounding)).to.equal(2n); - expect(await this.mock.$sqrt(144n, rounding)).to.equal(12n); - expect(await this.mock.$sqrt(999999n, rounding)).to.equal(999n); - expect(await this.mock.$sqrt(1000000n, rounding)).to.equal(1000n); - expect(await this.mock.$sqrt(1000001n, rounding)).to.equal(1000n); - expect(await this.mock.$sqrt(1002000n, rounding)).to.equal(1000n); - expect(await this.mock.$sqrt(1002001n, rounding)).to.equal(1001n); - expect(await this.mock.$sqrt(ethers.MaxUint256, rounding)).to.equal(340282366920938463463374607431768211455n); + await expect(this.mock.$sqrt(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$sqrt(1n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$sqrt(2n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$sqrt(3n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$sqrt(4n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$sqrt(144n, rounding)).to.eventually.equal(12n); + await expect(this.mock.$sqrt(999999n, rounding)).to.eventually.equal(999n); + await expect(this.mock.$sqrt(1000000n, rounding)).to.eventually.equal(1000n); + await expect(this.mock.$sqrt(1000001n, rounding)).to.eventually.equal(1000n); + await expect(this.mock.$sqrt(1002000n, rounding)).to.eventually.equal(1000n); + await expect(this.mock.$sqrt(1002001n, rounding)).to.eventually.equal(1001n); + await expect(this.mock.$sqrt(ethers.MaxUint256, rounding)).to.eventually.equal( + 340282366920938463463374607431768211455n, + ); } }); it('rounds up', async function () { for (const rounding of RoundingUp) { - expect(await this.mock.$sqrt(0n, rounding)).to.equal(0n); - expect(await this.mock.$sqrt(1n, rounding)).to.equal(1n); - expect(await this.mock.$sqrt(2n, rounding)).to.equal(2n); - expect(await this.mock.$sqrt(3n, rounding)).to.equal(2n); - expect(await this.mock.$sqrt(4n, rounding)).to.equal(2n); - expect(await this.mock.$sqrt(144n, rounding)).to.equal(12n); - expect(await this.mock.$sqrt(999999n, rounding)).to.equal(1000n); - expect(await this.mock.$sqrt(1000000n, rounding)).to.equal(1000n); - expect(await this.mock.$sqrt(1000001n, rounding)).to.equal(1001n); - expect(await this.mock.$sqrt(1002000n, rounding)).to.equal(1001n); - expect(await this.mock.$sqrt(1002001n, rounding)).to.equal(1001n); - expect(await this.mock.$sqrt(ethers.MaxUint256, rounding)).to.equal(340282366920938463463374607431768211456n); + await expect(this.mock.$sqrt(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$sqrt(1n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$sqrt(2n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$sqrt(3n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$sqrt(4n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$sqrt(144n, rounding)).to.eventually.equal(12n); + await expect(this.mock.$sqrt(999999n, rounding)).to.eventually.equal(1000n); + await expect(this.mock.$sqrt(1000000n, rounding)).to.eventually.equal(1000n); + await expect(this.mock.$sqrt(1000001n, rounding)).to.eventually.equal(1001n); + await expect(this.mock.$sqrt(1002000n, rounding)).to.eventually.equal(1001n); + await expect(this.mock.$sqrt(1002001n, rounding)).to.eventually.equal(1001n); + await expect(this.mock.$sqrt(ethers.MaxUint256, rounding)).to.eventually.equal( + 340282366920938463463374607431768211456n, + ); } }); }); @@ -458,33 +609,33 @@ describe('Math', function () { describe('log2', function () { it('rounds down', async function () { for (const rounding of RoundingDown) { - expect(await this.mock.$log2(0n, rounding)).to.equal(0n); - expect(await this.mock.$log2(1n, rounding)).to.equal(0n); - expect(await this.mock.$log2(2n, rounding)).to.equal(1n); - expect(await this.mock.$log2(3n, rounding)).to.equal(1n); - expect(await this.mock.$log2(4n, rounding)).to.equal(2n); - expect(await this.mock.$log2(5n, rounding)).to.equal(2n); - expect(await this.mock.$log2(6n, rounding)).to.equal(2n); - expect(await this.mock.$log2(7n, rounding)).to.equal(2n); - expect(await this.mock.$log2(8n, rounding)).to.equal(3n); - expect(await this.mock.$log2(9n, rounding)).to.equal(3n); - expect(await this.mock.$log2(ethers.MaxUint256, rounding)).to.equal(255n); + await expect(this.mock.$log2(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log2(1n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log2(2n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log2(3n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log2(4n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log2(5n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log2(6n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log2(7n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log2(8n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log2(9n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log2(ethers.MaxUint256, rounding)).to.eventually.equal(255n); } }); it('rounds up', async function () { for (const rounding of RoundingUp) { - expect(await this.mock.$log2(0n, rounding)).to.equal(0n); - expect(await this.mock.$log2(1n, rounding)).to.equal(0n); - expect(await this.mock.$log2(2n, rounding)).to.equal(1n); - expect(await this.mock.$log2(3n, rounding)).to.equal(2n); - expect(await this.mock.$log2(4n, rounding)).to.equal(2n); - expect(await this.mock.$log2(5n, rounding)).to.equal(3n); - expect(await this.mock.$log2(6n, rounding)).to.equal(3n); - expect(await this.mock.$log2(7n, rounding)).to.equal(3n); - expect(await this.mock.$log2(8n, rounding)).to.equal(3n); - expect(await this.mock.$log2(9n, rounding)).to.equal(4n); - expect(await this.mock.$log2(ethers.MaxUint256, rounding)).to.equal(256n); + await expect(this.mock.$log2(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log2(1n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log2(2n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log2(3n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log2(4n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log2(5n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log2(6n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log2(7n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log2(8n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log2(9n, rounding)).to.eventually.equal(4n); + await expect(this.mock.$log2(ethers.MaxUint256, rounding)).to.eventually.equal(256n); } }); }); @@ -492,37 +643,37 @@ describe('Math', function () { describe('log10', function () { it('rounds down', async function () { for (const rounding of RoundingDown) { - expect(await this.mock.$log10(0n, rounding)).to.equal(0n); - expect(await this.mock.$log10(1n, rounding)).to.equal(0n); - expect(await this.mock.$log10(2n, rounding)).to.equal(0n); - expect(await this.mock.$log10(9n, rounding)).to.equal(0n); - expect(await this.mock.$log10(10n, rounding)).to.equal(1n); - expect(await this.mock.$log10(11n, rounding)).to.equal(1n); - expect(await this.mock.$log10(99n, rounding)).to.equal(1n); - expect(await this.mock.$log10(100n, rounding)).to.equal(2n); - expect(await this.mock.$log10(101n, rounding)).to.equal(2n); - expect(await this.mock.$log10(999n, rounding)).to.equal(2n); - expect(await this.mock.$log10(1000n, rounding)).to.equal(3n); - expect(await this.mock.$log10(1001n, rounding)).to.equal(3n); - expect(await this.mock.$log10(ethers.MaxUint256, rounding)).to.equal(77n); + await expect(this.mock.$log10(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log10(1n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log10(2n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log10(9n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log10(10n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log10(11n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log10(99n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log10(100n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log10(101n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log10(999n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log10(1000n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log10(1001n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log10(ethers.MaxUint256, rounding)).to.eventually.equal(77n); } }); it('rounds up', async function () { for (const rounding of RoundingUp) { - expect(await this.mock.$log10(0n, rounding)).to.equal(0n); - expect(await this.mock.$log10(1n, rounding)).to.equal(0n); - expect(await this.mock.$log10(2n, rounding)).to.equal(1n); - expect(await this.mock.$log10(9n, rounding)).to.equal(1n); - expect(await this.mock.$log10(10n, rounding)).to.equal(1n); - expect(await this.mock.$log10(11n, rounding)).to.equal(2n); - expect(await this.mock.$log10(99n, rounding)).to.equal(2n); - expect(await this.mock.$log10(100n, rounding)).to.equal(2n); - expect(await this.mock.$log10(101n, rounding)).to.equal(3n); - expect(await this.mock.$log10(999n, rounding)).to.equal(3n); - expect(await this.mock.$log10(1000n, rounding)).to.equal(3n); - expect(await this.mock.$log10(1001n, rounding)).to.equal(4n); - expect(await this.mock.$log10(ethers.MaxUint256, rounding)).to.equal(78n); + await expect(this.mock.$log10(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log10(1n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log10(2n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log10(9n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log10(10n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log10(11n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log10(99n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log10(100n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log10(101n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log10(999n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log10(1000n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log10(1001n, rounding)).to.eventually.equal(4n); + await expect(this.mock.$log10(ethers.MaxUint256, rounding)).to.eventually.equal(78n); } }); }); @@ -530,31 +681,31 @@ describe('Math', function () { describe('log256', function () { it('rounds down', async function () { for (const rounding of RoundingDown) { - expect(await this.mock.$log256(0n, rounding)).to.equal(0n); - expect(await this.mock.$log256(1n, rounding)).to.equal(0n); - expect(await this.mock.$log256(2n, rounding)).to.equal(0n); - expect(await this.mock.$log256(255n, rounding)).to.equal(0n); - expect(await this.mock.$log256(256n, rounding)).to.equal(1n); - expect(await this.mock.$log256(257n, rounding)).to.equal(1n); - expect(await this.mock.$log256(65535n, rounding)).to.equal(1n); - expect(await this.mock.$log256(65536n, rounding)).to.equal(2n); - expect(await this.mock.$log256(65537n, rounding)).to.equal(2n); - expect(await this.mock.$log256(ethers.MaxUint256, rounding)).to.equal(31n); + await expect(this.mock.$log256(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log256(1n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log256(2n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log256(255n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log256(256n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log256(257n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log256(65535n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log256(65536n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log256(65537n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log256(ethers.MaxUint256, rounding)).to.eventually.equal(31n); } }); it('rounds up', async function () { for (const rounding of RoundingUp) { - expect(await this.mock.$log256(0n, rounding)).to.equal(0n); - expect(await this.mock.$log256(1n, rounding)).to.equal(0n); - expect(await this.mock.$log256(2n, rounding)).to.equal(1n); - expect(await this.mock.$log256(255n, rounding)).to.equal(1n); - expect(await this.mock.$log256(256n, rounding)).to.equal(1n); - expect(await this.mock.$log256(257n, rounding)).to.equal(2n); - expect(await this.mock.$log256(65535n, rounding)).to.equal(2n); - expect(await this.mock.$log256(65536n, rounding)).to.equal(2n); - expect(await this.mock.$log256(65537n, rounding)).to.equal(3n); - expect(await this.mock.$log256(ethers.MaxUint256, rounding)).to.equal(32n); + await expect(this.mock.$log256(0n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log256(1n, rounding)).to.eventually.equal(0n); + await expect(this.mock.$log256(2n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log256(255n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log256(256n, rounding)).to.eventually.equal(1n); + await expect(this.mock.$log256(257n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log256(65535n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log256(65536n, rounding)).to.eventually.equal(2n); + await expect(this.mock.$log256(65537n, rounding)).to.eventually.equal(3n); + await expect(this.mock.$log256(ethers.MaxUint256, rounding)).to.eventually.equal(32n); } }); }); diff --git a/test/utils/math/SignedMath.t.sol b/test/utils/math/SignedMath.t.sol index bbad109b7..98a40a139 100644 --- a/test/utils/math/SignedMath.t.sol +++ b/test/utils/math/SignedMath.t.sol @@ -8,18 +8,18 @@ import {Math} from "../../../contracts/utils/math/Math.sol"; import {SignedMath} from "../../../contracts/utils/math/SignedMath.sol"; contract SignedMathTest is Test { - function testSymbolicTernary(bool f, int256 a, int256 b) public { + function testSymbolicTernary(bool f, int256 a, int256 b) public pure { assertEq(SignedMath.ternary(f, a, b), f ? a : b); } // MIN & MAX - function testSymbolicMinMax(int256 a, int256 b) public { + function testSymbolicMinMax(int256 a, int256 b) public pure { assertEq(SignedMath.min(a, b), a < b ? a : b); assertEq(SignedMath.max(a, b), a > b ? a : b); } // MIN - function testSymbolicMin(int256 a, int256 b) public { + function testSymbolicMin(int256 a, int256 b) public pure { int256 result = SignedMath.min(a, b); assertLe(result, a); @@ -28,7 +28,7 @@ contract SignedMathTest is Test { } // MAX - function testSymbolicMax(int256 a, int256 b) public { + function testSymbolicMax(int256 a, int256 b) public pure { int256 result = SignedMath.max(a, b); assertGe(result, a); @@ -38,7 +38,7 @@ contract SignedMathTest is Test { // AVERAGE // 1. simple test, not full int256 range - function testAverage1(int256 a, int256 b) public { + function testAverage1(int256 a, int256 b) public pure { a = bound(a, type(int256).min / 2, type(int256).max / 2); b = bound(b, type(int256).min / 2, type(int256).max / 2); @@ -48,7 +48,7 @@ contract SignedMathTest is Test { } // 2. more complex test, full int256 range - function testAverage2(int256 a, int256 b) public { + function testAverage2(int256 a, int256 b) public pure { (int256 result, int256 min, int256 max) = ( SignedMath.average(a, b), SignedMath.min(a, b), @@ -69,7 +69,7 @@ contract SignedMathTest is Test { } // ABS - function testSymbolicAbs(int256 a) public { + function testSymbolicAbs(int256 a) public pure { uint256 result = SignedMath.abs(a); unchecked { diff --git a/test/utils/structs/Checkpoints.t.sol b/test/utils/structs/Checkpoints.t.sol index 1f4b344c5..74d8fb8b8 100644 --- a/test/utils/structs/Checkpoints.t.sol +++ b/test/utils/structs/Checkpoints.t.sol @@ -10,7 +10,7 @@ import {Checkpoints} from "@openzeppelin/contracts/utils/structs/Checkpoints.sol contract CheckpointsTrace224Test is Test { using Checkpoints for Checkpoints.Trace224; - // Maximum gap between keys used during the fuzzing tests: the `_prepareKeys` function with make sure that + // Maximum gap between keys used during the fuzzing tests: the `_prepareKeys` function will make sure that // key#n+1 is in the [key#n, key#n + _KEY_MAX_GAP] range. uint8 internal constant _KEY_MAX_GAP = 64; @@ -30,7 +30,7 @@ contract CheckpointsTrace224Test is Test { } } - function _assertLatestCheckpoint(bool exist, uint32 key, uint224 value) internal { + function _assertLatestCheckpoint(bool exist, uint32 key, uint224 value) internal view { (bool _exist, uint32 _key, uint224 _value) = _ckpts.latestCheckpoint(); assertEq(_exist, exist); assertEq(_key, key); @@ -118,7 +118,7 @@ contract CheckpointsTrace224Test is Test { contract CheckpointsTrace208Test is Test { using Checkpoints for Checkpoints.Trace208; - // Maximum gap between keys used during the fuzzing tests: the `_prepareKeys` function with make sure that + // Maximum gap between keys used during the fuzzing tests: the `_prepareKeys` function will make sure that // key#n+1 is in the [key#n, key#n + _KEY_MAX_GAP] range. uint8 internal constant _KEY_MAX_GAP = 64; @@ -138,7 +138,7 @@ contract CheckpointsTrace208Test is Test { } } - function _assertLatestCheckpoint(bool exist, uint48 key, uint208 value) internal { + function _assertLatestCheckpoint(bool exist, uint48 key, uint208 value) internal view { (bool _exist, uint48 _key, uint208 _value) = _ckpts.latestCheckpoint(); assertEq(_exist, exist); assertEq(_key, key); @@ -226,7 +226,7 @@ contract CheckpointsTrace208Test is Test { contract CheckpointsTrace160Test is Test { using Checkpoints for Checkpoints.Trace160; - // Maximum gap between keys used during the fuzzing tests: the `_prepareKeys` function with make sure that + // Maximum gap between keys used during the fuzzing tests: the `_prepareKeys` function will make sure that // key#n+1 is in the [key#n, key#n + _KEY_MAX_GAP] range. uint8 internal constant _KEY_MAX_GAP = 64; @@ -246,7 +246,7 @@ contract CheckpointsTrace160Test is Test { } } - function _assertLatestCheckpoint(bool exist, uint96 key, uint160 value) internal { + function _assertLatestCheckpoint(bool exist, uint96 key, uint160 value) internal view { (bool _exist, uint96 _key, uint160 _value) = _ckpts.latestCheckpoint(); assertEq(_exist, exist); assertEq(_key, key); diff --git a/test/utils/structs/EnumerableMap.behavior.js b/test/utils/structs/EnumerableMap.behavior.js index 37da41795..c80eec934 100644 --- a/test/utils/structs/EnumerableMap.behavior.js +++ b/test/utils/structs/EnumerableMap.behavior.js @@ -117,6 +117,49 @@ function shouldBehaveLikeMap() { }); }); + describe('clear', function () { + it('clears a single entry', async function () { + await this.methods.set(this.keyA, this.valueA); + + await this.methods.clear(); + + expect(await this.methods.contains(this.keyA)).to.be.false; + await expectMembersMatch(this.methods, [], []); + }); + + it('clears multiple entries', async function () { + await this.methods.set(this.keyA, this.valueA); + await this.methods.set(this.keyB, this.valueB); + await this.methods.set(this.keyC, this.valueC); + + await this.methods.clear(); + + expect(await this.methods.contains(this.keyA)).to.be.false; + expect(await this.methods.contains(this.keyB)).to.be.false; + expect(await this.methods.contains(this.keyC)).to.be.false; + await expectMembersMatch(this.methods, [], []); + }); + + it('does not revert on empty map', async function () { + await this.methods.clear(); + }); + + it('clear then add entry', async function () { + await this.methods.set(this.keyA, this.valueA); + await this.methods.set(this.keyB, this.valueB); + await this.methods.set(this.keyC, this.valueC); + + await this.methods.clear(); + + await this.methods.set(this.keyA, this.valueA); + + expect(await this.methods.contains(this.keyA)).to.be.true; + expect(await this.methods.contains(this.keyB)).to.be.false; + expect(await this.methods.contains(this.keyC)).to.be.false; + await expectMembersMatch(this.methods, [this.keyA], [this.valueA]); + }); + }); + describe('read', function () { beforeEach(async function () { await this.methods.set(this.keyA, this.valueA); diff --git a/test/utils/structs/EnumerableMap.test.js b/test/utils/structs/EnumerableMap.test.js index 5362e873a..cb4b77a65 100644 --- a/test/utils/structs/EnumerableMap.test.js +++ b/test/utils/structs/EnumerableMap.test.js @@ -26,6 +26,7 @@ async function fixture() { get: `$get_EnumerableMap_${name}(uint256,${keyType})`, tryGet: `$tryGet_EnumerableMap_${name}(uint256,${keyType})`, remove: `$remove_EnumerableMap_${name}(uint256,${keyType})`, + clear: `$clear_EnumerableMap_${name}(uint256)`, length: `$length_EnumerableMap_${name}(uint256)`, at: `$at_EnumerableMap_${name}(uint256,uint256)`, contains: `$contains_EnumerableMap_${name}(uint256,${keyType})`, diff --git a/test/utils/structs/EnumerableSet.behavior.js b/test/utils/structs/EnumerableSet.behavior.js index d3d4f26d5..fb932680c 100644 --- a/test/utils/structs/EnumerableSet.behavior.js +++ b/test/utils/structs/EnumerableSet.behavior.js @@ -47,7 +47,7 @@ function shouldBehaveLikeSet() { it('retrieves existing element', async function () { await this.methods.add(this.valueA); - expect(await this.methods.at(0)).to.equal(this.valueA); + expect(await this.methods.at(0)).to.deep.equal(this.valueA); }); }); @@ -109,6 +109,49 @@ function shouldBehaveLikeSet() { expect(await this.methods.contains(this.valueB)).to.be.false; }); }); + + describe('clear', function () { + it('clears a single value', async function () { + await this.methods.add(this.valueA); + + await this.methods.clear(); + + expect(await this.methods.contains(this.valueA)).to.be.false; + await expectMembersMatch(this.methods, []); + }); + + it('clears multiple values', async function () { + await this.methods.add(this.valueA); + await this.methods.add(this.valueB); + await this.methods.add(this.valueC); + + await this.methods.clear(); + + expect(await this.methods.contains(this.valueA)).to.be.false; + expect(await this.methods.contains(this.valueB)).to.be.false; + expect(await this.methods.contains(this.valueC)).to.be.false; + await expectMembersMatch(this.methods, []); + }); + + it('does not revert on empty set', async function () { + await this.methods.clear(); + }); + + it('clear then add value', async function () { + await this.methods.add(this.valueA); + await this.methods.add(this.valueB); + await this.methods.add(this.valueC); + + await this.methods.clear(); + + await this.methods.add(this.valueA); + + expect(await this.methods.contains(this.valueA)).to.be.true; + expect(await this.methods.contains(this.valueB)).to.be.false; + expect(await this.methods.contains(this.valueC)).to.be.false; + await expectMembersMatch(this.methods, [this.valueA]); + }); + }); } module.exports = { diff --git a/test/utils/structs/EnumerableSet.test.js b/test/utils/structs/EnumerableSet.test.js index 66d666058..1f92727a4 100644 --- a/test/utils/structs/EnumerableSet.test.js +++ b/test/utils/structs/EnumerableSet.test.js @@ -27,6 +27,7 @@ async function fixture() { methods: getMethods(mock, { add: `$add(uint256,${type})`, remove: `$remove(uint256,${type})`, + clear: `$clear_EnumerableSet_${name}(uint256)`, contains: `$contains(uint256,${type})`, length: `$length_EnumerableSet_${name}(uint256)`, at: `$at_EnumerableSet_${name}(uint256,uint256)`, diff --git a/test/utils/structs/Heap.t.sol b/test/utils/structs/Heap.t.sol index 434f37f66..ba7d77012 100644 --- a/test/utils/structs/Heap.t.sol +++ b/test/utils/structs/Heap.t.sol @@ -12,7 +12,7 @@ contract Uint256HeapTest is Test { Heap.Uint256Heap internal heap; - function _validateHeap(function(uint256, uint256) view returns (bool) comp) internal { + function _validateHeap(function(uint256, uint256) view returns (bool) comp) internal view { for (uint32 i = 1; i < heap.length(); ++i) { assertFalse(comp(heap.tree[i], heap.tree[(i - 1) / 2])); } diff --git a/test/utils/structs/MerkleTree.test.js b/test/utils/structs/MerkleTree.test.js index bec39ceea..f0380ed02 100644 --- a/test/utils/structs/MerkleTree.test.js +++ b/test/utils/structs/MerkleTree.test.js @@ -5,18 +5,23 @@ const { PANIC_CODES } = require('@nomicfoundation/hardhat-chai-matchers/panic'); const { StandardMerkleTree } = require('@openzeppelin/merkle-tree'); const { generators } = require('../../helpers/random'); +const { range } = require('../../helpers/iterate'); -const makeTree = (leaves = [ethers.ZeroHash]) => +const DEPTH = 4; // 16 slots + +const makeTree = (leaves = [], length = 2 ** DEPTH, zero = ethers.ZeroHash) => StandardMerkleTree.of( - leaves.map(leaf => [leaf]), + [] + .concat( + leaves, + Array.from({ length: length - leaves.length }, () => zero), + ) + .map(leaf => [leaf]), ['bytes32'], { sortLeaves: false }, ); -const hashLeaf = leaf => makeTree().leafHash([leaf]); - -const DEPTH = 4n; // 16 slots -const ZERO = hashLeaf(ethers.ZeroHash); +const ZERO = makeTree().leafHash([ethers.ZeroHash]); async function fixture() { const mock = await ethers.deployContract('MerkleTreeMock'); @@ -30,57 +35,132 @@ describe('MerkleTree', function () { }); it('sets initial values at setup', async function () { - const merkleTree = makeTree(Array.from({ length: 2 ** Number(DEPTH) }, () => ethers.ZeroHash)); + const merkleTree = makeTree(); - expect(await this.mock.root()).to.equal(merkleTree.root); - expect(await this.mock.depth()).to.equal(DEPTH); - expect(await this.mock.nextLeafIndex()).to.equal(0n); + await expect(this.mock.root()).to.eventually.equal(merkleTree.root); + await expect(this.mock.depth()).to.eventually.equal(DEPTH); + await expect(this.mock.nextLeafIndex()).to.eventually.equal(0n); }); describe('push', function () { - it('tree is correctly updated', async function () { - const leaves = Array.from({ length: 2 ** Number(DEPTH) }, () => ethers.ZeroHash); + it('pushing correctly updates the tree', async function () { + const leaves = []; // for each leaf slot - for (const i in leaves) { - // generate random leaf and hash it - const hashedLeaf = hashLeaf((leaves[i] = generators.bytes32())); + for (const i in range(2 ** DEPTH)) { + // generate random leaf + leaves.push(generators.bytes32()); - // update leaf list and rebuild tree. + // rebuild tree. const tree = makeTree(leaves); + const hash = tree.leafHash(tree.at(i)); // push value to tree - await expect(this.mock.push(hashedLeaf)).to.emit(this.mock, 'LeafInserted').withArgs(hashedLeaf, i, tree.root); + await expect(this.mock.push(hash)).to.emit(this.mock, 'LeafInserted').withArgs(hash, i, tree.root); // check tree - expect(await this.mock.root()).to.equal(tree.root); - expect(await this.mock.nextLeafIndex()).to.equal(BigInt(i) + 1n); + await expect(this.mock.root()).to.eventually.equal(tree.root); + await expect(this.mock.nextLeafIndex()).to.eventually.equal(BigInt(i) + 1n); } }); - it('revert when tree is full', async function () { + it('pushing to a full tree reverts', async function () { await Promise.all(Array.from({ length: 2 ** Number(DEPTH) }).map(() => this.mock.push(ethers.ZeroHash))); await expect(this.mock.push(ethers.ZeroHash)).to.be.revertedWithPanic(PANIC_CODES.TOO_MUCH_MEMORY_ALLOCATED); }); }); + describe('update', function () { + for (const { leafCount, leafIndex } of range(2 ** DEPTH + 1).flatMap(leafCount => + range(leafCount).map(leafIndex => ({ leafCount, leafIndex })), + )) + it(`updating a leaf correctly updates the tree (leaf #${leafIndex + 1}/${leafCount})`, async function () { + // initial tree + const leaves = Array.from({ length: leafCount }, generators.bytes32); + const oldTree = makeTree(leaves); + + // fill tree and verify root + for (const i in leaves) { + await this.mock.push(oldTree.leafHash(oldTree.at(i))); + } + await expect(this.mock.root()).to.eventually.equal(oldTree.root); + + // create updated tree + leaves[leafIndex] = generators.bytes32(); + const newTree = makeTree(leaves); + + const oldLeafHash = oldTree.leafHash(oldTree.at(leafIndex)); + const newLeafHash = newTree.leafHash(newTree.at(leafIndex)); + + // perform update + await expect(this.mock.update(leafIndex, oldLeafHash, newLeafHash, oldTree.getProof(leafIndex))) + .to.emit(this.mock, 'LeafUpdated') + .withArgs(oldLeafHash, newLeafHash, leafIndex, newTree.root); + + // verify updated root + await expect(this.mock.root()).to.eventually.equal(newTree.root); + + // if there is still room in the tree, fill it + for (const i of range(leafCount, 2 ** DEPTH)) { + // push new value and rebuild tree + leaves.push(generators.bytes32()); + const nextTree = makeTree(leaves); + + // push and verify root + await this.mock.push(nextTree.leafHash(nextTree.at(i))); + await expect(this.mock.root()).to.eventually.equal(nextTree.root); + } + }); + + it('replacing a leaf that was not previously pushed reverts', async function () { + // changing leaf 0 on an empty tree + await expect(this.mock.update(1, ZERO, ZERO, [])) + .to.be.revertedWithCustomError(this.mock, 'MerkleTreeUpdateInvalidIndex') + .withArgs(1, 0); + }); + + it('replacing a leaf using an invalid proof reverts', async function () { + const leafCount = 4; + const leafIndex = 2; + + const leaves = Array.from({ length: leafCount }, generators.bytes32); + const tree = makeTree(leaves); + + // fill tree and verify root + for (const i in leaves) { + await this.mock.push(tree.leafHash(tree.at(i))); + } + await expect(this.mock.root()).to.eventually.equal(tree.root); + + const oldLeafHash = tree.leafHash(tree.at(leafIndex)); + const newLeafHash = generators.bytes32(); + const proof = tree.getProof(leafIndex); + // invalid proof (tamper) + proof[1] = generators.bytes32(); + + await expect(this.mock.update(leafIndex, oldLeafHash, newLeafHash, proof)).to.be.revertedWithCustomError( + this.mock, + 'MerkleTreeUpdateInvalidProof', + ); + }); + }); + it('reset', async function () { // empty tree - const zeroLeaves = Array.from({ length: 2 ** Number(DEPTH) }, () => ethers.ZeroHash); - const zeroTree = makeTree(zeroLeaves); + const emptyTree = makeTree(); // tree with one element - const leaves = Array.from({ length: 2 ** Number(DEPTH) }, () => ethers.ZeroHash); - const hashedLeaf = hashLeaf((leaves[0] = generators.bytes32())); // fill first leaf and hash it + const leaves = [generators.bytes32()]; const tree = makeTree(leaves); + const hash = tree.leafHash(tree.at(0)); // root should be that of a zero tree - expect(await this.mock.root()).to.equal(zeroTree.root); + expect(await this.mock.root()).to.equal(emptyTree.root); expect(await this.mock.nextLeafIndex()).to.equal(0n); // push leaf and check root - await expect(this.mock.push(hashedLeaf)).to.emit(this.mock, 'LeafInserted').withArgs(hashedLeaf, 0, tree.root); + await expect(this.mock.push(hash)).to.emit(this.mock, 'LeafInserted').withArgs(hash, 0, tree.root); expect(await this.mock.root()).to.equal(tree.root); expect(await this.mock.nextLeafIndex()).to.equal(1n); @@ -88,11 +168,11 @@ describe('MerkleTree', function () { // reset tree await this.mock.setup(DEPTH, ZERO); - expect(await this.mock.root()).to.equal(zeroTree.root); + expect(await this.mock.root()).to.equal(emptyTree.root); expect(await this.mock.nextLeafIndex()).to.equal(0n); // re-push leaf and check root - await expect(this.mock.push(hashedLeaf)).to.emit(this.mock, 'LeafInserted').withArgs(hashedLeaf, 0, tree.root); + await expect(this.mock.push(hash)).to.emit(this.mock, 'LeafInserted').withArgs(hash, 0, tree.root); expect(await this.mock.root()).to.equal(tree.root); expect(await this.mock.nextLeafIndex()).to.equal(1n);