+
+
+ {/* Main Swap Interface */}
+
+
+ );
+}
+```
+
+## Future Enhancements
+
+This structure makes it easy to:
+
+- Add new swap steps
+- Implement different swap interfaces
+- Add unit tests for individual components
+- Integrate with state management libraries
+- Add more complex business logic
+- Create different themes or layouts
diff --git a/cache/solidity-files-cache.json b/cache/solidity-files-cache.json
new file mode 100644
index 000000000..ce07db607
--- /dev/null
+++ b/cache/solidity-files-cache.json
@@ -0,0 +1 @@
+{"_format":"","paths":{"artifacts":"out","build_infos":"out/build-info","sources":"contracts","tests":"test","scripts":"script","libraries":["lib"]},"files":{"contracts/SimpleSwapPool.sol":{"lastModificationDate":1758781461227,"contentHash":"b41cd3aa5727c8ef","interfaceReprHash":null,"sourceName":"contracts/SimpleSwapPool.sol","imports":["lib/openzeppelin-contracts/contracts/access/Ownable.sol","lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol","lib/openzeppelin-contracts/contracts/utils/Context.sol","lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol","lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"],"versionRequirement":"^0.8.20","artifacts":{"SimpleSwapPool":{"0.8.20":{"default":{"path":"SimpleSwapPool.sol/SimpleSwapPool.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"lastModificationDate":1758781544568,"contentHash":"aeede215495e3727","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/access/Ownable.sol","imports":["lib/openzeppelin-contracts/contracts/utils/Context.sol"],"versionRequirement":"^0.8.20","artifacts":{"Ownable":{"0.8.20":{"default":{"path":"Ownable.sol/Ownable.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"lastModificationDate":1758781544576,"contentHash":"1822a75bab6fed91","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","imports":["lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"],"versionRequirement":">=0.6.2","artifacts":{"IERC1363":{"0.8.20":{"default":{"path":"IERC1363.sol/IERC1363.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"lastModificationDate":1758781544576,"contentHash":"1a826f6d4b769022","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","imports":["lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"],"versionRequirement":">=0.4.16","artifacts":{},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"lastModificationDate":1758781544577,"contentHash":"e318fc72a6d9cc43","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","imports":["lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"],"versionRequirement":">=0.4.16","artifacts":{},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"lastModificationDate":1758781544598,"contentHash":"1dcd768972ff31b3","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","imports":[],"versionRequirement":">=0.4.16","artifacts":{"IERC20":{"0.8.20":{"default":{"path":"IERC20.sol/IERC20.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"lastModificationDate":1758781544600,"contentHash":"609309defd5425b6","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol","imports":["lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol","lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol","lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol","lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol","lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol"],"versionRequirement":"^0.8.20","artifacts":{"SafeERC20":{"0.8.20":{"default":{"path":"SafeERC20.sol/SafeERC20.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"lastModificationDate":1758781544604,"contentHash":"16db1f8b2f7183f5","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/utils/Context.sol","imports":[],"versionRequirement":"^0.8.20","artifacts":{"Context":{"0.8.20":{"default":{"path":"Context.sol/Context.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"lastModificationDate":1758781544606,"contentHash":"dae049b0b5c78a59","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol","imports":["lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol"],"versionRequirement":"^0.8.20","artifacts":{"ReentrancyGuard":{"0.8.20":{"default":{"path":"ReentrancyGuard.sol/ReentrancyGuard.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol":{"lastModificationDate":1758781544607,"contentHash":"261e9fcb6515866e","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/utils/StorageSlot.sol","imports":[],"versionRequirement":"^0.8.20","artifacts":{"StorageSlot":{"0.8.20":{"default":{"path":"StorageSlot.sol/StorageSlot.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"lastModificationDate":1758781544612,"contentHash":"021ac46c8076d0ee","interfaceReprHash":null,"sourceName":"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol","imports":[],"versionRequirement":">=0.4.16","artifacts":{"IERC165":{"0.8.20":{"default":{"path":"IERC165.sol/IERC165.json","build_id":"a832e574b044cc1a"}}}},"seenByCompiler":true}},"builds":["a832e574b044cc1a"],"profiles":{"default":{"solc":{"optimizer":{"enabled":true,"runs":200},"metadata":{"useLiteralContent":false,"bytecodeHash":"ipfs","appendCBOR":true},"outputSelection":{"*":{"*":["abi","evm.bytecode.object","evm.bytecode.sourceMap","evm.bytecode.linkReferences","evm.deployedBytecode.object","evm.deployedBytecode.sourceMap","evm.deployedBytecode.linkReferences","evm.deployedBytecode.immutableReferences","evm.methodIdentifiers","metadata"]}},"evmVersion":"paris","viaIR":false,"libraries":{}},"vyper":{"evmVersion":"paris","outputSelection":{"*":{"*":["abi","evm.bytecode","evm.deployedBytecode"]}}}}},"preprocessed":false,"mocks":[]}
\ No newline at end of file
diff --git a/con/.github/workflows/test.yml b/con/.github/workflows/test.yml
new file mode 100644
index 000000000..4481ec6a8
--- /dev/null
+++ b/con/.github/workflows/test.yml
@@ -0,0 +1,40 @@
+name: CI
+
+on:
+ push:
+ pull_request:
+ workflow_dispatch:
+
+env:
+ FOUNDRY_PROFILE: ci
+
+jobs:
+ check:
+ name: Foundry project
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ submodules: recursive
+
+ - name: Install Foundry
+ uses: foundry-rs/foundry-toolchain@v1
+
+ - name: Show Forge version
+ run: |
+ forge --version
+
+ - name: Run Forge fmt
+ run: |
+ forge fmt --check
+ id: fmt
+
+ - name: Run Forge build
+ run: |
+ forge build --sizes
+ id: build
+
+ - name: Run Forge tests
+ run: |
+ forge test -vvv
+ id: test
diff --git a/con/.gitignore b/con/.gitignore
new file mode 100644
index 000000000..85198aaa5
--- /dev/null
+++ b/con/.gitignore
@@ -0,0 +1,14 @@
+# Compiler files
+cache/
+out/
+
+# Ignores development broadcast logs
+!/broadcast
+/broadcast/*/31337/
+/broadcast/**/dry-run/
+
+# Docs
+docs/
+
+# Dotenv file
+.env
diff --git a/con/README.md b/con/README.md
new file mode 100644
index 000000000..9265b4558
--- /dev/null
+++ b/con/README.md
@@ -0,0 +1,66 @@
+## Foundry
+
+**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+
+Foundry consists of:
+
+- **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
+- **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
+- **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
+- **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+
+## Documentation
+
+https://book.getfoundry.sh/
+
+## Usage
+
+### Build
+
+```shell
+$ forge build
+```
+
+### Test
+
+```shell
+$ forge test
+```
+
+### Format
+
+```shell
+$ forge fmt
+```
+
+### Gas Snapshots
+
+```shell
+$ forge snapshot
+```
+
+### Anvil
+
+```shell
+$ anvil
+```
+
+### Deploy
+
+```shell
+$ forge script script/Counter.s.sol:CounterScript --rpc-url 
+
+[](https://github.com/OpenZeppelin/openzeppelin-contracts/releases/latest)
+[](https://www.npmjs.org/package/@openzeppelin/contracts)
+[](https://codecov.io/gh/OpenZeppelin/openzeppelin-contracts)
+[](https://www.gitpoap.io/gh/OpenZeppelin/openzeppelin-contracts)
+[](https://docs.openzeppelin.com/contracts)
+[](https://forum.openzeppelin.com/)
+
+**A library for secure smart contract development.** Build on a solid foundation of community-vetted code.
+
+ * Implementations of standards like [ERC20](https://docs.openzeppelin.com/contracts/erc20) and [ERC721](https://docs.openzeppelin.com/contracts/erc721).
+ * Flexible [role-based permissioning](https://docs.openzeppelin.com/contracts/access-control) scheme.
+ * Reusable [Solidity components](https://docs.openzeppelin.com/contracts/utilities) to build custom contracts and complex decentralized systems.
+
+:mage: **Not sure how to get started?** Check out [Contracts Wizard](https://wizard.openzeppelin.com/) โ an interactive smart contract generator.
+
+:building_construction: **Want to scale your decentralized application?** Check out [OpenZeppelin Defender](https://openzeppelin.com/defender) โ a mission-critical developer security platform to code, audit, deploy, monitor, and operate with confidence.
+
+> [!IMPORTANT]
+> OpenZeppelin Contracts uses semantic versioning to communicate backwards compatibility of its API and storage layout. For upgradeable contracts, the storage layout of different major versions should be assumed incompatible, for example, it is unsafe to upgrade from 4.9.3 to 5.0.0. Learn more at [Backwards Compatibility](https://docs.openzeppelin.com/contracts/backwards-compatibility).
+
+## Overview
+
+### Installation
+
+#### Hardhat (npm)
+
+```
+$ npm install @openzeppelin/contracts
+```
+
+#### Foundry (git)
+
+> [!WARNING]
+> When installing via git, it is a common error to use the `master` branch. This is a development branch that should be avoided in favor of tagged releases. The release process involves security measures that the `master` branch does not guarantee.
+
+> [!WARNING]
+> Foundry installs the latest version initially, but subsequent `forge update` commands will use the `master` branch.
+
+```
+$ forge install OpenZeppelin/openzeppelin-contracts
+```
+
+Add `@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/` in `remappings.txt.`
+
+### Usage
+
+Once installed, you can use the contracts in the library by importing them:
+
+```solidity
+pragma solidity ^0.8.20;
+
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+
+contract MyCollectible is ERC721 {
+ constructor() ERC721("MyCollectible", "MCO") {
+ }
+}
+```
+
+_If you're new to smart contract development, head to [Developing Smart Contracts](https://docs.openzeppelin.com/learn/developing-smart-contracts) to learn about creating a new project and compiling your contracts._
+
+To keep your system secure, you should **always** use the installed code as-is, and neither copy-paste it from online sources nor modify it yourself. The library is designed so that only the contracts and functions you use are deployed, so you don't need to worry about it needlessly increasing gas costs.
+
+## Learn More
+
+The guides in the [documentation site](https://docs.openzeppelin.com/contracts) will teach about different concepts, and how to use the related contracts that OpenZeppelin Contracts provides:
+
+* [Access Control](https://docs.openzeppelin.com/contracts/access-control): decide who can perform each of the actions on your system.
+* [Tokens](https://docs.openzeppelin.com/contracts/tokens): create tradeable assets or collectives, and distribute them via [Crowdsales](https://docs.openzeppelin.com/contracts/crowdsales).
+* [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' 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.
+
+* [The Hitchhikerโs Guide to Smart Contracts in Ethereum](https://blog.openzeppelin.com/the-hitchhikers-guide-to-smart-contracts-in-ethereum-848f08001f05) will help you get an overview of the various tools available for smart contract development, and help you set up your environment.
+* [A Gentle Introduction to Ethereum Programming, Part 1](https://blog.openzeppelin.com/a-gentle-introduction-to-ethereum-programming-part-1-783cc7796094) provides very useful information on an introductory level, including many basic concepts from the Ethereum platform.
+* For a more in-depth dive, you may read the guide [Designing the Architecture for Your Ethereum Application](https://blog.openzeppelin.com/designing-the-architecture-for-your-ethereum-application-9cec086f8317), which discusses how to better structure your application and its relationship to the real world.
+
+## Security
+
+This project is maintained by [OpenZeppelin](https://openzeppelin.com) with the goal of providing a secure and reliable library of smart contract components for the ecosystem. We address security through risk management in various areas such as engineering and open source best practices, scoping and API design, multi-layered review processes, and incident response preparedness.
+
+The [OpenZeppelin Contracts Security Center](https://contracts.openzeppelin.com/security) contains more details about the secure development process.
+
+The security policy is detailed in [`SECURITY.md`](./SECURITY.md) as well, and specifies how you can report security vulnerabilities, which versions will receive security patches, and how to stay informed about them. We run a [bug bounty program on Immunefi](https://immunefi.com/bounty/openzeppelin) to reward the responsible disclosure of vulnerabilities.
+
+The engineering guidelines we follow to promote project quality can be found in [`GUIDELINES.md`](./GUIDELINES.md).
+
+Past audits can be found in [`audits/`](./audits).
+
+Smart contracts are a nascent technology and carry a high level of technical risk and uncertainty. Although OpenZeppelin is well known for its security audits, using OpenZeppelin Contracts is not a substitute for a security audit.
+
+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. As set out further in the Terms, you acknowledge that you are solely responsible for any use of OpenZeppelin Contracts and you assume all risks associated with any such use.
+
+## Contribute
+
+OpenZeppelin Contracts exists thanks to its contributors. There are many ways you can participate and help build high quality software. Check out the [contribution guide](CONTRIBUTING.md)!
+
+## License
+
+OpenZeppelin Contracts is released under the [MIT License](LICENSE).
+
+## Legal
+
+Your use of this Project is governed by the terms found at www.openzeppelin.com/tos (the "Terms").
diff --git a/con/lib/openzeppelin-contracts/RELEASING.md b/con/lib/openzeppelin-contracts/RELEASING.md
new file mode 100644
index 000000000..6820d403d
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/RELEASING.md
@@ -0,0 +1,45 @@
+# 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 consistent and reliable.
+
+## Changesets
+
+[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
+
+The release cycle happens on release branches called `release-vX.Y`. Each of these branches starts as a release candidate (rc) and is eventually promoted to final.
+
+A release branch can be updated with cherry-picked patches from `master`, or may sometimes be committed to directly in the case of old releases. These commits will lead to a new release candidate or a patch increment depending on the state of the release branch.
+
+```mermaid
+ %%{init: {'gitGraph': {'mainBranchName': 'master'}} }%%
+ gitGraph
+ commit id: "Feature A"
+ commit id: "Feature B"
+ branch release-vX.Y
+ commit id: "Start release"
+ commit id: "Release vX.Y.0-rc.0"
+
+ checkout master
+ commit id: "Feature C"
+ commit id: "Fix A"
+
+ checkout release-vX.Y
+ cherry-pick id: "Fix A" tag: ""
+ commit id: "Release vX.Y.0-rc.1"
+ commit id: "Release vX.Y.0"
+
+ checkout master
+ merge release-vX.Y
+ commit id: "Feature D"
+ commit id: "Patch B"
+
+ checkout release-vX.Y
+ cherry-pick id: "Patch B" tag: ""
+ commit id: "Release vX.Y.1"
+
+ checkout master
+ merge release-vX.Y
+ commit id: "Feature E"
+```
diff --git a/con/lib/openzeppelin-contracts/SECURITY.md b/con/lib/openzeppelin-contracts/SECURITY.md
new file mode 100644
index 000000000..0d09b3e93
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/SECURITY.md
@@ -0,0 +1,43 @@
+# Security Policy
+
+Security vulnerabilities should be disclosed to the project maintainers through [Immunefi], or alternatively by email to security@openzeppelin.com.
+
+[Immunefi]: https://immunefi.com/bounty/openzeppelin
+
+## Bug Bounty
+
+Responsible disclosure of security vulnerabilities is rewarded through a bug bounty program on [Immunefi].
+
+There is a bonus reward for issues introduced in release candidates that are reported before making it into a stable release. Learn more about release candidates at [`RELEASING.md`](./RELEASING.md).
+
+## Security Patches
+
+Security vulnerabilities will be patched as soon as responsibly possible, and published as an advisory on this repository (see [advisories]) and on the affected npm packages.
+
+[advisories]: https://github.com/OpenZeppelin/openzeppelin-contracts/security/advisories
+
+Projects that build on OpenZeppelin Contracts are encouraged to clearly state, in their source code and websites, how to be contacted about security issues in the event that a direct notification is considered necessary. We recommend including it in the NatSpec for the contract as `/// @custom:security-contact security@example.com`.
+
+Additionally, we recommend installing the library through npm and setting up vulnerability alerts such as [Dependabot].
+
+[Dependabot]: https://docs.github.com/en/code-security/supply-chain-security/understanding-your-software-supply-chain/about-supply-chain-security#what-is-dependabot
+
+### Supported Versions
+
+Security patches will be released for the latest minor of a given major release. For example, if an issue is found in versions >=4.6.0 and the latest is 4.8.0, the patch will be released only in version 4.8.1.
+
+Only critical severity bug fixes will be backported to past major releases.
+
+| Version | Critical security fixes | Other security fixes |
+| ------- | ----------------------- | -------------------- |
+| 5.x | :white_check_mark: | :white_check_mark: |
+| 4.9 | :white_check_mark: | :x: |
+| 3.4 | :white_check_mark: | :x: |
+| 2.5 | :x: | :x: |
+| < 2.0 | :x: | :x: |
+
+Note as well that the Solidity language itself only guarantees security updates for the latest release.
+
+## Legal
+
+Blockchain is a nascent technology and carries a high level of risk and uncertainty. OpenZeppelin makes certain software available under open source licenses, which disclaim all warranties in relation to the project and which limits the liability of OpenZeppelin. Subject to any particular licensing terms, your use of the project is governed by the terms found at [www.openzeppelin.com/tos](https://www.openzeppelin.com/tos) (the "Terms"). As set out in the Terms, you are solely responsible for any use of the project 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 issues or vulnerabilities or alert you to all or any of the risks of utilizing the project.
diff --git a/con/lib/openzeppelin-contracts/audits/2017-03.md b/con/lib/openzeppelin-contracts/audits/2017-03.md
new file mode 100644
index 000000000..d54174ecb
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/audits/2017-03.md
@@ -0,0 +1,292 @@
+# OpenZeppelin Audit
+
+NOTE ON 2021-07-19: This report makes reference to Zeppelin, OpenZeppelin, OpenZeppelin Contracts, the OpenZeppelin team, and OpenZeppelin library. Many of these things have since been renamed and know that this audit applies to what is currently called the OpenZeppelin Contracts which are maintained by the OpenZeppelin Contracts Community.
+
+March, 2017
+Authored by Dennis Peterson and Peter Vessenes
+
+# Introduction
+
+Zeppelin requested that New Alchemy perform an audit of the contracts in their OpenZeppelin library. The OpenZeppelin contracts are a set of contracts intended to be a safe building block for a variety of uses by parties that may not be as sophisticated as the OpenZeppelin team. It is a design goal that the contracts be deployable safely and "as-is".
+
+The contracts are hosted at:
+
+https://github.com/OpenZeppelin/zeppelin-solidity
+
+All the contracts in the "contracts" folder are in scope.
+
+The git commit hash we evaluated is:
+9c5975a706b076b7000e8179f8101e0c61024c87
+
+# Disclaimer
+
+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
+
+Overall the OpenZeppelin codebase is of reasonably high quality -- it is clean, modular and follows best practices throughout.
+
+It is still in flux as a codebase, and needs better documentation per file as to expected behavior and future plans. It probably needs more comprehensive and aggressive tests written by people less nice than the current OpenZeppelin team.
+
+We identified two critical errors and one moderate issue, and would not recommend this commit hash for public use until these bugs are remedied.
+
+The repository includes a set of Truffle unit tests, a requirement and best practice for smart contracts like these; we recommend these be bulked up.
+
+# Discussion
+
+## Big Picture: Is This A Worthwhile Project?
+
+As soon as a developer touches OpenZeppelin contracts, they will modify something, leaving them in an un-audited state. We do not recommend developers deploy any unaudited code to the Blockchain if it will handle money, information or other things of value.
+
+> "In accordance with Unix philosophy, Perl gives you enough rope to hang yourself"
+> --Larry Wall
+
+We think this is an incredibly worthwhile project -- aided by the high code quality. Creating a framework that can be easily extended helps increase the average code quality on the Blockchain by charting a course for developers and encouraging containment of modifications to certain sections.
+
+> "Rust: The language that makes you take the safety off before shooting yourself in the foot"
+> -- (@mbrubeck)
+
+We think much more could be done here, and recommend the OpenZeppelin team keep at this and keep focusing on the design goal of removing rope and adding safety.
+
+## Solidity Version Updates Recommended
+
+Most of the code uses Solidity 0.4.11, but some files under `Ownership` are marked 0.4.0. These should be updated.
+
+Solidity 0.4.10 will add several features which could be useful in these contracts:
+
+- `assert(condition)`, which throws if the condition is false
+
+- `revert()`, which rolls back without consuming all remaining gas.
+
+- `address.transfer(value)`, which is like `send` but automatically propagates exceptions, and supports `.gas()`. See https://github.com/ethereum/solidity/issues/610 for more on this.
+
+## Error Handling: Throw vs Return False
+Solidity standards allow two ways to handle an error -- either calling `throw` or returning `false`. Both have benefits. In particular, a `throw` guarantees a complete wipe of the call stack (up to the preceding external call), whereas `false` allows a function to continue.
+
+In general we prefer `throw` in our code audits, because it is simpler -- it's less for an engineer to keep track of. Returning `false` and using logic to check results can quickly become a poorly-tracked state machine, and this sort of complexity can cause errors.
+
+In the OpenZeppelin contracts, both styles are used in different parts of the codebase. `SimpleToken` transfers throw upon failure, while the full ERC20 token returns `false`. Some modifiers `throw`, others just wrap the function body in a conditional, effectively allowing the function to return false if the condition is not met.
+
+We don't love this, and would usually recommend you stick with one style or the other throughout the codebase.
+
+In at least one case, these different techniques are combined cleverly (see the Multisig comments, line 65). As a set of contracts intended for general use, we recommend you either strive for more consistency or document explicit design criteria that govern which techniques are used where.
+
+Note that it may be impossible to use either one in all situations. For example, SafeMath functions pretty much have to throw upon failure, but ERC20 specifies returning booleans. Therefore we make no particular recommendations, but simply point out inconsistencies to consider.
+
+# Critical Issues
+
+## Stuck Ether in Crowdsale contract
+CrowdsaleToken.sol has no provision for withdrawing the raised ether. We *strongly* recommend a standard `withdraw` function be added. There is no scenario in which someone should deploy this contract as is, whether for testing or live.
+
+## Recursive Call in MultisigWallet
+Line 45 of `MultisigWallet.sol` checks if the amount being sent by `execute` is under a daily limit.
+
+This function can only be called by the "Owner". As a first angle of attack, it's worth asking what will happen if the multisig wallet owners reset the daily limit by approving a call to `resetSpentToday`.
+
+If a chain of calls can be constructed in which the owner confirms the `resetSpentToday` function and then withdraws through `execute` in a recursive call, the contract can be drained. In fact, this could be done without a recursive call, just through repeated `execute` calls alternating with the `confirm` calls.
+
+We are still working through the confirmation protocol in `Shareable.sol`, but we are not convinced that this is impossible, in fact it looks possible. The flexibility any shared owner has in being able to revoke confirmation later is another worrisome angle of approach even if some simple patches are included.
+
+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 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.
+
+We do not recommend using the MultisigWallet until these issues are fixed.
+
+# Moderate to Minor Issues
+
+## PullPayment
+PullPayment.sol needs some work. It has no explicit provision for cancelling a payment. This would be desirable in a number of scenarios; consider a payee losing their wallet, or giving a griefing address, or just an address that requires more than the default gas offered by `send`.
+
+`asyncSend` has no overflow checking. This is a bad plan. We recommend overflow and underflow checking at the layer closest to the data manipulation.
+
+`asyncSend` allows more balance to be queued up for sending than the contract holds. This is probably a bad idea, or at the very least should be called something different. If the intent is to allow this, it should have provisions for dealing with race conditions between competing `withdrawPayments` calls.
+
+It would be nice to see how many payments are pending. This would imply a bit of a rewrite; we recommend this contract get some design time, and that developers don't rely on it in its current state.
+
+## Shareable Contract
+
+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.
+
+No sanity checks on the initial constructor's `required` argument are worrisome as well.
+
+# Line by Line Comments
+
+## Lifecycle
+
+### Killable
+
+Very simple, allows owner to call selfdestruct, sending funds to owner. No issues. However, note that `selfdestruct` should typically not be used; it is common that a developer may want to access data in a former contract, and they may not understand that `selfdestruct` limits access to the contract. We recommend better documentation about this dynamic, and an alternate function name for `kill` like `completelyDestroy` while `kill` would perhaps merely send funds to the owner.
+
+Also note that a killable function allows the owner to take funds regardless of other logic. This may be desirable or undesirable depending on the circumstances. Perhaps `Killable` should have a different name as well.
+
+### Migrations
+
+I presume that the goal of this contract is to allow and annotate a migration to a new smart contract address. We are not clear here how this would be accomplished by the code; we'd like to review with the OpenZeppelin team.
+
+### Pausable
+
+We like these pauses! Note that these allow significant griefing potential by owners, and that this might not be obvious to participants in smart contracts using the OpenZeppelin framework. We would recommend that additional sample logic be added to for instance the TokenContract showing safer use of the pause and resume functions. In particular, we would recommend a timelock after which anyone could unpause the contract.
+
+The modifiers use the pattern `if(bool){_;}`. This is fine for functions that return false upon failure, but could be problematic for functions expected to throw upon failure. See our comments above on standardizing on `throw` or `return(false)`.
+
+## Ownership
+
+### Ownable
+
+Line 19: Modifier throws if doesn't meet condition, in contrast to some other inheritable modifiers (e.g. in Pausable) that use `if(bool){_;}`.
+
+### Claimable
+
+Inherits from Ownable but the existing owner sets a pendingOwner who has to claim ownership.
+
+Line 17: Another modifier that throws.
+
+### DelayedClaimable
+
+Is there any reason to descend from Ownable directly, instead of just Claimable, which descends from Ownable? If not, descending from both just adds confusion.
+
+### Contactable
+
+Allows owner to set a public string of contract information. No issues.
+
+### Shareable
+
+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 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.
+
+Line 61: Why is `ownerIndex` keyed by addresses hashed to `uint`s? Why not use the addresses directly, so `ownerIndex` is less obscure, and so there's stronger typing?
+
+Line 62: Do not love `++i) ... owners[2+ i]`. Makes me do math, which is not what I want to do. I want to not have to do math.
+
+There should probably be a function for adding a new operation, so the developer doesn't have to work directly with the internal data. (This would make the multisig contract even shorter.)
+
+There's a `revoke` function but not a `propose` function that we can see.
+
+Beware reordering. If `propose` allows the user to choose a bytes string for their proposal, bad things(TM) will happen as currently written.
+
+
+### Multisig
+
+Just an interface. Note it allows changing an owner address, but not changing the number of owners. This is somewhat limiting but also simplifies implementation.
+
+## Payment
+
+### PullPayment
+
+Safe from reentrance attack since ether send is at the end, plus it uses `.send()` rather than `.call.value()`.
+
+There's an argument to be made that `.call.value()` is a better option *if* you're sure that it will be done after all state updates, since `.send` will fail if the recipient has an expensive fallback function. However, in the context of a function meant to be embedded in other contracts, it's probably better to use `.send`. One possible compromise is to add a function which allows only the owner to send ether via `.call.value`.
+
+If you don't use `call.value` you should implement a `cancel` function in case some value is pending here.
+
+Line 14:
+Doesn't use safeAdd. Although it appears that payout amounts can only be increased, in fact the payer could lower the payout as much as desired via overflow. Also, the payer could add a large non-overflowing amount, causing the payment to exceed the contract balance and therefore fail when withdraw is attempted.
+
+Recommendation: track the sum of non-withdrawn asyncSends, and don't allow a new one which exceeds the leftover balance. If it's ever desirable to make payments revocable, it should be done explicitly.
+
+## Tokens
+
+### ERC20
+
+Standard ERC20 interface only.
+
+There's a security hole in the standard, reported at Edcon: `approve` does not protect against race conditions and simply replaces the current value. An approved spender could wait for the owner to call `approve` again, then attempt to spend the old limit before the new limit is applied. If successful, this attacker could successfully spend the sum of both limits.
+
+This could be fixed by either (1) including the old limit as a parameter, so the update will fail if some gets spent, or (2) using the value parameter as a delta instead of replacement value.
+
+This is not fixable while adhering to the current full ERC20 standard, though it would be possible to add a "secureApprove" function. The impact isn't extreme since at least you can only be attacked by addresses you approved. Also, users could mitigate this by always setting spending limits to zero and checking for spends, before setting the new limit.
+
+Edcon slides:
+https://drive.google.com/file/d/0ByMtMw2hul0EN3NCaVFHSFdxRzA/view
+
+### ERC20Basic
+
+Simpler interface skipping the Approve function. Note this departs from ERC20 in another way: transfer throws instead of returning false.
+
+### BasicToken
+
+Uses `SafeSub` and `SafeMath`, so transfer `throw`s instead of returning false. This complies with ERC20Basic but not the actual ERC20 standard.
+
+### StandardToken
+
+Implementation of full ERC20 token.
+
+Transfer() and transferFrom() use SafeMath functions, which will cause them to throw instead of returning false. Not a security issue but departs from standard.
+
+### SimpleToken
+
+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
+
+StandardToken which mints tokens at a fixed price when sent ether.
+
+There's no provision for owner withdrawing the ether. As a sample for crowdsales it should be Ownable and allow the owner to withdraw ether, rather than stranding the ether in the contract.
+
+Note: an alternative pattern is a mint() function which is only callable from a separate crowdsale contract, so any sort of rules can be added without modifying the token itself.
+
+### VestedToken
+
+Lines 23, 27:
+Functions `transfer()` and `transferFrom()` have a modifier canTransfer which throws if not enough tokens are available. However, transfer() returns a boolean success. Inconsistent treatment of failure conditions may cause problems for other contracts using the token. (Note that transferableTokens() relies on safeSub(), so will also throw if there's insufficient balance.)
+
+Line 64:
+Delete not actually necessary since the value is overwritten in the next line anyway.
+
+## Root level
+
+### Bounty
+
+Avoids potential race condition by having each researcher deploy a separate contract for attack; if a research manages to break his associated contract, other researchers can't immediately claim the reward, they have to reproduce the attack in their own contracts.
+
+A developer could subvert this intent by implementing `deployContract()` to always return the same address. However, this would break the `researchers` mapping, updating the researcher address associated with the contract. This could be prevented by blocking rewrites in `researchers`.
+
+### DayLimit
+
+The modifier `limitedDaily` calls `underLimit`, which both checks that the spend is below the daily limit, and adds the input value to the daily spend. This is fine if all functions throw upon failure. However, not all OpenZeppelin functions do this; there are functions that returns false, and modifiers that wrap the function body in `if (bool) {_;}`. In these cases, `_value` will be added to `spentToday`, but ether may not actually be sent because other preconditions were not met. (However in the OpenZeppelin multisig this is not a problem.)
+
+Lines 4, 11:
+Comment claims that `DayLimit` is multiowned, and Shareable is imported, but DayLimit does not actually inherit from Shareable. The intent may be for child contracts to inherit from Shareable (as Multisig does); in this case the import should be removed and the comment altered.
+
+Line 46:
+Manual overflow check instead of using safeAdd. Since this is called from a function that throws upon failure anyway, there's no real downside to using safeAdd.
+
+### LimitBalance
+
+No issues.
+
+### MultisigWallet
+
+Lines 28, 76, 80:
+`kill`, `setDailyLimit`, and `resetSpentToday` only happen with multisig approval, and hashes for these actions are logged by Shareable. However, they should probably post their own events for easy reading.
+
+Line 45:
+This call to underLimit will reduce the daily limit, and then either throw or return 0. So in this case there's no danger that the limit will be reduced without the operation going through.
+
+Line 65:
+Shareable's onlyManyOwners will take the user's confirmation, and execute the function body if and only if enough users have confirmed. Whole thing throws if the send fails, which will roll back the confirmation. Confirm returns false if not enough have confirmed yet, true if the whole thing succeeds, and throws only in the exceptional circumstance that the designated transaction unexpectedly fails. Elegant design.
+
+Line 68:
+Throw here is good but note this function can fail either by returning false or by throwing.
+
+Line 92:
+A bit odd to split `clearPending()` between this contract and Shareable. However this does allow contracts inheriting from Shareable to use custom structs for pending transactions.
+
+
+### SafeMath
+
+Another interesting comment from the same Edcon presentation was that the overflow behavior of Solidity is undocumented, so in theory, source code that relies on it could break with a future revision.
+
+However, compiled code should be fine, and in the unlikely event that the compiler is revised in this way, there should be plenty of warning. (But this is an argument for keeping overflow checks isolated in SafeMath.)
+
+Aside from that small caveat, these are fine.
+
diff --git a/con/lib/openzeppelin-contracts/audits/2018-10.pdf b/con/lib/openzeppelin-contracts/audits/2018-10.pdf
new file mode 100644
index 000000000..d5bf12741
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2018-10.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2022-10-Checkpoints.pdf b/con/lib/openzeppelin-contracts/audits/2022-10-Checkpoints.pdf
new file mode 100644
index 000000000..7e0d08387
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2022-10-Checkpoints.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2022-10-ERC4626.pdf b/con/lib/openzeppelin-contracts/audits/2022-10-ERC4626.pdf
new file mode 100644
index 000000000..154fe7521
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2022-10-ERC4626.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2023-05-v4.9.pdf b/con/lib/openzeppelin-contracts/audits/2023-05-v4.9.pdf
new file mode 100644
index 000000000..21cd7f593
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2023-05-v4.9.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2023-10-v5.0.pdf b/con/lib/openzeppelin-contracts/audits/2023-10-v5.0.pdf
new file mode 100644
index 000000000..991026ecd
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2023-10-v5.0.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2024-10-v5.1.pdf b/con/lib/openzeppelin-contracts/audits/2024-10-v5.1.pdf
new file mode 100644
index 000000000..4d85dc7ba
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2024-10-v5.1.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2024-12-v5.2.pdf b/con/lib/openzeppelin-contracts/audits/2024-12-v5.2.pdf
new file mode 100644
index 000000000..ef138f7ec
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2024-12-v5.2.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/2025-04-v5.3.pdf b/con/lib/openzeppelin-contracts/audits/2025-04-v5.3.pdf
new file mode 100644
index 000000000..8bf812ff5
Binary files /dev/null and b/con/lib/openzeppelin-contracts/audits/2025-04-v5.3.pdf differ
diff --git a/con/lib/openzeppelin-contracts/audits/README.md b/con/lib/openzeppelin-contracts/audits/README.md
new file mode 100644
index 000000000..cba0f2f74
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/audits/README.md
@@ -0,0 +1,20 @@
+# Audits
+
+| Date | Version | Commit | Auditor | Scope | Links |
+| ------------- | ------- | -------------------------------------------------------------------------------- | ------------ | -------------------- | ----------------------------------------------------------- |
+| April 2025 | v5.3.0 | [`d4b2e98`](https://github.com/openzeppelin/openzeppelin-contracts/tree/d4b2e98) | OpenZeppelin | v5.3 Changes | [๐](./2025-04-v5.3.pdf) |
+| 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
+
+| Date | Version | Commit | Tool | Scope | Links |
+| ------------ | ------- | --------- | ------- | -------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------ |
+| May 2022 | v4.7.0 | `109778c` | Certora | Initializable, GovernorPreventLateQuorum, ERC1155Burnable, ERC1155Pausable, ERC1155Supply, ERC1155Holder, ERC1155Receiver | [๐](../certora/reports/2022-05.pdf) |
+| March 2022 | v4.4.0 | `4088540` | Certora | ERC20Votes, ERC20FlashMint, ERC20Wrapper, TimelockController, ERC721Votes, Votes, AccessControl, ERC1155 | [๐](../certora/reports/2022-03.pdf) |
+| October 2021 | v4.4.0 | `4088540` | Certora | Governor, GovernorCountingSimple, GovernorProposalThreshold, GovernorTimelockControl, GovernorVotes, GovernorVotesQuorumFraction | [๐](../certora/reports/2021-10.pdf) |
diff --git a/con/lib/openzeppelin-contracts/certora/.gitignore b/con/lib/openzeppelin-contracts/certora/.gitignore
new file mode 100644
index 000000000..893adcd31
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/.gitignore
@@ -0,0 +1 @@
+patched
diff --git a/con/lib/openzeppelin-contracts/certora/Makefile b/con/lib/openzeppelin-contracts/certora/Makefile
new file mode 100644
index 000000000..d57d2ffdc
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/Makefile
@@ -0,0 +1,54 @@
+default: help
+
+SRC := ../contracts
+DST := patched
+DIFF := diff
+SRCS := $(shell find $(SRC) -type f)
+DSTS := $(shell find $(DST) -type f)
+DIFFS := $(shell find $(DIFF) -type f)
+
+###############################################################################
+# Apply all patches in the $DIFF folder to the $DST folder
+apply: $(DST) $(patsubst $(DIFF)/%.patch,$(DST)/%,$(subst _,/,$(DIFFS)))
+
+# Reset the $DST folder
+$(DST): FORCE
+ @rm -rf $@
+ @cp -r $(SRC) $@
+
+# Update a solidity file in the $DST directory using the corresponding patch
+$(DST)/%.sol: FORCE | $(DST)
+ @echo Applying patch to $@
+ @patch -p0 -d $(DST) < $(patsubst $(DST)_%,$(DIFF)/%.patch,$(subst /,_,$@))
+
+###############################################################################
+# Record all difference between $SRC and $DST in patches
+record: $(DIFF) $(patsubst %,$(DIFF)/%.patch,$(subst /,_,$(subst $(SRC)/,,$(SRCS)) $(subst $(DST)/,,$(DSTS))))
+
+# Create the $DIFF folder
+$(DIFF): FORCE
+ @rm -rf $@
+ @mkdir $@
+
+# Create the patch file by comparing the source and the destination
+$(DIFF)/%.patch: FORCE | $(DIFF)
+ @echo Generating patch $@
+ @diff -ruN \
+ $(patsubst $(DIFF)/%.patch,$(SRC)/%,$(subst _,/,$@)) \
+ $(patsubst $(DIFF)/%.patch,$(DST)/%,$(subst _,/,$@)) \
+ | sed 's+$(SRC)/++g' \
+ | sed 's+$(DST)/++g' \
+ > $@
+ @[ -s $@ ] || rm $@
+
+###############################################################################
+help:
+ @echo "usage:"
+ @echo " make apply: create $(DST) directory by applying the patches to $(SRC)"
+ @echo " make record: record the patches capturing the differences between $(SRC) and $(DST)"
+ @echo " make clean: remove all generated files (those ignored by git)"
+
+clean:
+ git clean -fdX
+
+FORCE: ;
diff --git a/con/lib/openzeppelin-contracts/certora/README.md b/con/lib/openzeppelin-contracts/certora/README.md
new file mode 100644
index 000000000..ff2ccdf7d
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/README.md
@@ -0,0 +1,60 @@
+# Running the certora verification tool
+
+These instructions detail the process for running Certora Verification Tool on OpenZeppelin Contracts.
+
+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.
+
+## Running the verification
+
+The Certora Verification Tool proves specs for contracts, which are defined by the `./specs.json` file along with their pre-configured options.
+
+The verification script `./run.js` is used to submit verification jobs to the Certora Verification service.
+
+You can run it from the root of the repository with the following command:
+
+```bash
+node certora/run.js [[CONTRACT_NAME:]SPEC_NAME] [OPTIONS...]
+```
+
+Where:
+
+- `CONTRACT_NAME` matches the `contract` key in the `./spec.json` file and may be empty. It will run all matching contracts if not provided.
+- `SPEC_NAME` refers to a `spec` key from the `./specs.json` file. It will run every spec if not provided.
+- `OPTIONS` extend the [Certora Prover CLI options](https://docs.certora.com/en/latest/docs/prover/cli/options.html#certora-prover-cli-options) and will respect the preconfigured options in the `specs.json` file.
+
+> **Note**
+> A single spec may be configured to run for multiple contracts, whereas a single contract may run multiple specs.
+
+Example usage:
+
+```bash
+node certora/run.js AccessControl # Run the AccessControl spec against every contract implementing it
+```
+
+## Adapting to changes in the contracts
+
+Some of our rules require the code to be simplified in various ways. Our primary tool for performing these simplifications is to run verification on a contract that extends the original contracts and overrides some of the methods. These "harness" contracts can be found in the `certora/harness` directory.
+
+This pattern does require some modifications to the original code: some methods need to be made virtual or public, for example. These changes are handled by applying a patch
+to the code before verification by running:
+
+```bash
+make -C certora apply
+```
+
+Before running the `certora/run.js` script, it's required to apply the corresponding patches to the `contracts` directory, placing the output in the `certora/patched` directory. Then, the contracts are verified by running the verification for the `certora/patched` directory.
+
+If the original contracts change, it is possible to create a conflict with the patch. In this case, the verify scripts will report an error message and output rejected changes in the `patched` directory. After merging the changes, run `make record` in the `certora` directory; this will regenerate the patch file, which can then be checked into git.
+
+For more information about the `make` scripts available, run:
+
+```bash
+make -C certora help
+```
diff --git a/con/lib/openzeppelin-contracts/certora/diff/access_manager_AccessManager.sol.patch b/con/lib/openzeppelin-contracts/certora/diff/access_manager_AccessManager.sol.patch
new file mode 100644
index 000000000..cfb6cdf2f
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/diff/access_manager_AccessManager.sol.patch
@@ -0,0 +1,97 @@
+--- access/manager/AccessManager.sol 2023-10-05 12:17:09.694051809 -0300
++++ access/manager/AccessManager.sol 2023-10-05 12:26:18.498688718 -0300
+@@ -6,7 +6,6 @@
+ import {IAccessManaged} from "./IAccessManaged.sol";
+ import {Address} from "../../utils/Address.sol";
+ import {Context} from "../../utils/Context.sol";
+-import {Multicall} from "../../utils/Multicall.sol";
+ import {Math} from "../../utils/math/Math.sol";
+ import {Time} from "../../utils/types/Time.sol";
+
+@@ -57,7 +56,8 @@
+ * mindful of the danger associated with functions such as {{Ownable-renounceOwnership}} or
+ * {{AccessControl-renounceRole}}.
+ */
+-contract AccessManager is Context, Multicall, IAccessManager {
++// NOTE: The FV version of this contract doesn't include Multicall because CVL HAVOCs on any `delegatecall`.
++contract AccessManager is Context, IAccessManager {
+ using Time for *;
+
+ // Structure that stores the details for a target contract.
+@@ -105,7 +105,7 @@
+
+ // Used to identify operations that are currently being executed via {execute}.
+ // This should be transient storage when supported by the EVM.
+- bytes32 private _executionId;
++ bytes32 internal _executionId; // private โ internal for FV
+
+ /**
+ * @dev Check that the caller is authorized to perform the operation, following the restrictions encoded in
+@@ -253,6 +253,11 @@
+ _setGrantDelay(roleId, newDelay);
+ }
+
++ // Exposed for FV
++ function _getTargetAdminDelayFull(address target) internal view virtual returns (uint32, uint32, uint48) {
++ return _targets[target].adminDelay.getFull();
++ }
++
+ /**
+ * @dev Internal version of {grantRole} without access control. Returns true if the role was newly granted.
+ *
+@@ -287,6 +292,11 @@
+ return newMember;
+ }
+
++ // Exposed for FV
++ function _getRoleGrantDelayFull(uint64 roleId) internal view virtual returns (uint32, uint32, uint48) {
++ return _roles[roleId].grantDelay.getFull();
++ }
++
+ /**
+ * @dev Internal version of {revokeRole} without access control. This logic is also used by {renounceRole}.
+ * Returns true if the role was previously granted.
+@@ -586,7 +596,7 @@
+ /**
+ * @dev Check if the current call is authorized according to admin logic.
+ */
+- function _checkAuthorized() private {
++ function _checkAuthorized() internal virtual { // private โ internal virtual for FV
+ address caller = _msgSender();
+ (bool immediate, uint32 delay) = _canCallSelf(caller, _msgData());
+ if (!immediate) {
+@@ -609,7 +619,7 @@
+ */
+ function _getAdminRestrictions(
+ bytes calldata data
+- ) private view returns (bool adminRestricted, uint64 roleAdminId, uint32 executionDelay) {
++ ) internal view returns (bool adminRestricted, uint64 roleAdminId, uint32 executionDelay) { // private โ internal for FV
+ if (data.length < 4) {
+ return (false, 0, 0);
+ }
+@@ -662,7 +672,7 @@
+ address caller,
+ address target,
+ bytes calldata data
+- ) private view returns (bool immediate, uint32 delay) {
++ ) internal view returns (bool immediate, uint32 delay) { // private โ internal for FV
+ if (target == address(this)) {
+ return _canCallSelf(caller, data);
+ } else {
+@@ -716,14 +726,14 @@
+ /**
+ * @dev Extracts the selector from calldata. Panics if data is not at least 4 bytes
+ */
+- function _checkSelector(bytes calldata data) private pure returns (bytes4) {
++ function _checkSelector(bytes calldata data) internal pure returns (bytes4) { // private โ internal for FV
+ return bytes4(data[0:4]);
+ }
+
+ /**
+ * @dev Hashing function for execute protection
+ */
+- function _hashExecutionId(address target, bytes4 selector) private pure returns (bytes32) {
++ function _hashExecutionId(address target, bytes4 selector) internal pure returns (bytes32) { // private โ internal for FV
+ return keccak256(abi.encode(target, selector));
+ }
+ }
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/AccessControlDefaultAdminRulesHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/AccessControlDefaultAdminRulesHarness.sol
new file mode 100644
index 000000000..e96883fa2
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/AccessControlDefaultAdminRulesHarness.sol
@@ -0,0 +1,46 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {AccessControlDefaultAdminRules} from "../patched/access/extensions/AccessControlDefaultAdminRules.sol";
+
+contract AccessControlDefaultAdminRulesHarness is AccessControlDefaultAdminRules {
+ uint48 private _delayIncreaseWait;
+
+ constructor(
+ uint48 initialDelay,
+ address initialDefaultAdmin,
+ uint48 delayIncreaseWait
+ ) AccessControlDefaultAdminRules(initialDelay, initialDefaultAdmin) {
+ _delayIncreaseWait = delayIncreaseWait;
+ }
+
+ // FV
+ function pendingDefaultAdmin_() external view returns (address) {
+ (address newAdmin, ) = pendingDefaultAdmin();
+ return newAdmin;
+ }
+
+ function pendingDefaultAdminSchedule_() external view returns (uint48) {
+ (, uint48 schedule) = pendingDefaultAdmin();
+ return schedule;
+ }
+
+ function pendingDelay_() external view returns (uint48) {
+ (uint48 newDelay, ) = pendingDefaultAdminDelay();
+ return newDelay;
+ }
+
+ function pendingDelaySchedule_() external view returns (uint48) {
+ (, uint48 schedule) = pendingDefaultAdminDelay();
+ return schedule;
+ }
+
+ function delayChangeWait_(uint48 newDelay) external view returns (uint48) {
+ return _delayChangeWait(newDelay);
+ }
+
+ // Overrides
+ function defaultAdminDelayIncreaseWait() public view override returns (uint48) {
+ return _delayIncreaseWait;
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/AccessControlHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/AccessControlHarness.sol
new file mode 100644
index 000000000..e862d3eca
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/AccessControlHarness.sol
@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {AccessControl} from "../patched/access/AccessControl.sol";
+
+contract AccessControlHarness is AccessControl {}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/AccessManagedHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/AccessManagedHarness.sol
new file mode 100644
index 000000000..50be23ad5
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/AccessManagedHarness.sol
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../patched/access/manager/IAccessManager.sol";
+import "../patched/access/manager/AccessManaged.sol";
+
+contract AccessManagedHarness is AccessManaged {
+ bytes internal SOME_FUNCTION_CALLDATA = abi.encodeCall(this.someFunction, ());
+
+ constructor(address initialAuthority) AccessManaged(initialAuthority) {}
+
+ function someFunction() public restricted() {
+ // Sanity for FV: the msg.data when calling this function should be the same as the data used when checking
+ // the schedule. This is a reformulation of `msg.data == SOME_FUNCTION_CALLDATA` that focuses on the operation
+ // hash for this call.
+ require(
+ IAccessManager(authority()).hashOperation(_msgSender(), address(this), msg.data)
+ ==
+ IAccessManager(authority()).hashOperation(_msgSender(), address(this), SOME_FUNCTION_CALLDATA)
+ );
+ }
+
+ function authority_canCall_immediate(address caller) public view returns (bool result) {
+ (result,) = AuthorityUtils.canCallWithDelay(authority(), caller, address(this), this.someFunction.selector);
+ }
+
+ function authority_canCall_delay(address caller) public view returns (uint32 result) {
+ (,result) = AuthorityUtils.canCallWithDelay(authority(), caller, address(this), this.someFunction.selector);
+ }
+
+ function authority_getSchedule(address caller) public view returns (uint48) {
+ IAccessManager manager = IAccessManager(authority());
+ return manager.getSchedule(manager.hashOperation(caller, address(this), SOME_FUNCTION_CALLDATA));
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/AccessManagerHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/AccessManagerHarness.sol
new file mode 100644
index 000000000..69295d467
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/AccessManagerHarness.sol
@@ -0,0 +1,116 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../patched/access/manager/AccessManager.sol";
+
+contract AccessManagerHarness is AccessManager {
+ // override with a storage slot that can basically take any value.
+ uint32 private _minSetback;
+
+ constructor(address initialAdmin) AccessManager(initialAdmin) {}
+
+ // FV
+ function minSetback() public view override returns (uint32) {
+ return _minSetback;
+ }
+
+ function canCall_immediate(address caller, address target, bytes4 selector) external view returns (bool result) {
+ (result,) = canCall(caller, target, selector);
+ }
+
+ function canCall_delay(address caller, address target, bytes4 selector) external view returns (uint32 result) {
+ (,result) = canCall(caller, target, selector);
+ }
+
+ function canCallExtended(address caller, address target, bytes calldata data) external view returns (bool, uint32) {
+ return _canCallExtended(caller, target, data);
+ }
+
+ function canCallExtended_immediate(address caller, address target, bytes calldata data) external view returns (bool result) {
+ (result,) = _canCallExtended(caller, target, data);
+ }
+
+ function canCallExtended_delay(address caller, address target, bytes calldata data) external view returns (uint32 result) {
+ (,result) = _canCallExtended(caller, target, data);
+ }
+
+ function getAdminRestrictions_restricted(bytes calldata data) external view returns (bool result) {
+ (result,,) = _getAdminRestrictions(data);
+ }
+
+ function getAdminRestrictions_roleAdminId(bytes calldata data) external view returns (uint64 result) {
+ (,result,) = _getAdminRestrictions(data);
+ }
+
+ function getAdminRestrictions_executionDelay(bytes calldata data) external view returns (uint32 result) {
+ (,,result) = _getAdminRestrictions(data);
+ }
+
+ function hasRole_isMember(uint64 roleId, address account) external view returns (bool result) {
+ (result,) = hasRole(roleId, account);
+ }
+
+ function hasRole_executionDelay(uint64 roleId, address account) external view returns (uint32 result) {
+ (,result) = hasRole(roleId, account);
+ }
+
+ function getAccess_since(uint64 roleId, address account) external view returns (uint48 result) {
+ (result,,,) = getAccess(roleId, account);
+ }
+
+ function getAccess_currentDelay(uint64 roleId, address account) external view returns (uint32 result) {
+ (,result,,) = getAccess(roleId, account);
+ }
+
+ function getAccess_pendingDelay(uint64 roleId, address account) external view returns (uint32 result) {
+ (,,result,) = getAccess(roleId, account);
+ }
+
+ function getAccess_effect(uint64 roleId, address account) external view returns (uint48 result) {
+ (,,,result) = getAccess(roleId, account);
+ }
+
+ function getTargetAdminDelay_after(address target) public view virtual returns (uint32 result) {
+ (,result,) = _getTargetAdminDelayFull(target);
+ }
+
+ function getTargetAdminDelay_effect(address target) public view virtual returns (uint48 result) {
+ (,,result) = _getTargetAdminDelayFull(target);
+ }
+
+ function getRoleGrantDelay_after(uint64 roleId) public view virtual returns (uint32 result) {
+ (,result,) = _getRoleGrantDelayFull(roleId);
+ }
+
+ function getRoleGrantDelay_effect(uint64 roleId) public view virtual returns (uint48 result) {
+ (,,result) = _getRoleGrantDelayFull(roleId);
+ }
+
+ function hashExecutionId(address target, bytes4 selector) external pure returns (bytes32) {
+ return _hashExecutionId(target, selector);
+ }
+
+ function executionId() external view returns (bytes32) {
+ return _executionId;
+ }
+
+ // Pad with zeros (and don't revert) if data is too short.
+ function getSelector(bytes calldata data) external pure returns (bytes4) {
+ return bytes4(data);
+ }
+
+ function getFirstArgumentAsAddress(bytes calldata data) external pure returns (address) {
+ return abi.decode(data[0x04:0x24], (address));
+ }
+
+ function getFirstArgumentAsUint64(bytes calldata data) external pure returns (uint64) {
+ return abi.decode(data[0x04:0x24], (uint64));
+ }
+
+ function _checkAuthorized() internal override {
+ // We need this hack otherwise certora will assume _checkSelector(_msgData()) can return anything :/
+ require(msg.sig == _checkSelector(_msgData()));
+ super._checkAuthorized();
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/DoubleEndedQueueHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/DoubleEndedQueueHarness.sol
new file mode 100644
index 000000000..d684c7382
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/DoubleEndedQueueHarness.sol
@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {DoubleEndedQueue} from "../patched/utils/structs/DoubleEndedQueue.sol";
+
+contract DoubleEndedQueueHarness {
+ using DoubleEndedQueue for DoubleEndedQueue.Bytes32Deque;
+
+ DoubleEndedQueue.Bytes32Deque private _deque;
+
+ function pushFront(bytes32 value) external {
+ _deque.pushFront(value);
+ }
+
+ function pushBack(bytes32 value) external {
+ _deque.pushBack(value);
+ }
+
+ function popFront() external returns (bytes32 value) {
+ return _deque.popFront();
+ }
+
+ function popBack() external returns (bytes32 value) {
+ return _deque.popBack();
+ }
+
+ function clear() external {
+ _deque.clear();
+ }
+
+ function begin() external view returns (uint128) {
+ return _deque._begin;
+ }
+
+ function end() external view returns (uint128) {
+ return _deque._end;
+ }
+
+ function length() external view returns (uint256) {
+ return _deque.length();
+ }
+
+ function empty() external view returns (bool) {
+ return _deque.empty();
+ }
+
+ function front() external view returns (bytes32 value) {
+ return _deque.front();
+ }
+
+ function back() external view returns (bytes32 value) {
+ return _deque.back();
+ }
+
+ function at_(uint256 index) external view returns (bytes32 value) {
+ return _deque.at(index);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/ERC20FlashMintHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/ERC20FlashMintHarness.sol
new file mode 100644
index 000000000..2f989b243
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/ERC20FlashMintHarness.sol
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../patched/token/ERC20/ERC20.sol";
+import "../patched/token/ERC20/extensions/ERC20Permit.sol";
+import "../patched/token/ERC20/extensions/ERC20FlashMint.sol";
+
+contract ERC20FlashMintHarness is ERC20, ERC20Permit, ERC20FlashMint {
+ uint256 someFee;
+ address someFeeReceiver;
+
+ constructor(string memory name, string memory symbol) ERC20(name, symbol) ERC20Permit(name) {}
+
+ function mint(address account, uint256 amount) external {
+ _mint(account, amount);
+ }
+
+ function burn(address account, uint256 amount) external {
+ _burn(account, amount);
+ }
+
+ // public accessor
+ function flashFeeReceiver() public view returns (address) {
+ return someFeeReceiver;
+ }
+
+ // internal hook
+ function _flashFee(address, uint256) internal view override returns (uint256) {
+ return someFee;
+ }
+
+ function _flashFeeReceiver() internal view override returns (address) {
+ return someFeeReceiver;
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/ERC20PermitHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/ERC20PermitHarness.sol
new file mode 100644
index 000000000..08113f4ea
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/ERC20PermitHarness.sol
@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {ERC20Permit, ERC20} from "../patched/token/ERC20/extensions/ERC20Permit.sol";
+
+contract ERC20PermitHarness is ERC20Permit {
+ constructor(string memory name, string memory symbol) ERC20(name, symbol) ERC20Permit(name) {}
+
+ function mint(address account, uint256 amount) external {
+ _mint(account, amount);
+ }
+
+ function burn(address account, uint256 amount) external {
+ _burn(account, amount);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/ERC20WrapperHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/ERC20WrapperHarness.sol
new file mode 100644
index 000000000..ca183ad92
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/ERC20WrapperHarness.sol
@@ -0,0 +1,34 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC20Permit} from "../patched/token/ERC20/extensions/ERC20Permit.sol";
+import {ERC20Wrapper, IERC20, ERC20} from "../patched/token/ERC20/extensions/ERC20Wrapper.sol";
+
+contract ERC20WrapperHarness is ERC20Permit, ERC20Wrapper {
+ constructor(
+ IERC20 _underlying,
+ string memory _name,
+ string memory _symbol
+ ) ERC20(_name, _symbol) ERC20Permit(_name) ERC20Wrapper(_underlying) {}
+
+ function underlyingTotalSupply() public view returns (uint256) {
+ return underlying().totalSupply();
+ }
+
+ function underlyingBalanceOf(address account) public view returns (uint256) {
+ return underlying().balanceOf(account);
+ }
+
+ function underlyingAllowanceToThis(address account) public view returns (uint256) {
+ return underlying().allowance(account, address(this));
+ }
+
+ function recover(address account) public returns (uint256) {
+ return _recover(account);
+ }
+
+ function decimals() public view override(ERC20Wrapper, ERC20) returns (uint8) {
+ return super.decimals();
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/ERC3156FlashBorrowerHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/ERC3156FlashBorrowerHarness.sol
new file mode 100644
index 000000000..1c76da2d4
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/ERC3156FlashBorrowerHarness.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+
+import {IERC3156FlashBorrower} from "../patched/interfaces/IERC3156FlashBorrower.sol";
+
+pragma solidity ^0.8.20;
+
+contract ERC3156FlashBorrowerHarness is IERC3156FlashBorrower {
+ bytes32 somethingToReturn;
+
+ function onFlashLoan(address, address, uint256, uint256, bytes calldata) external view override returns (bytes32) {
+ return somethingToReturn;
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/ERC721Harness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/ERC721Harness.sol
new file mode 100644
index 000000000..69c4c205a
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/ERC721Harness.sol
@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {ERC721} from "../patched/token/ERC721/ERC721.sol";
+
+contract ERC721Harness is ERC721 {
+ constructor(string memory name, string memory symbol) ERC721(name, symbol) {}
+
+ function mint(address account, uint256 tokenId) external {
+ _mint(account, tokenId);
+ }
+
+ function safeMint(address to, uint256 tokenId) external {
+ _safeMint(to, tokenId);
+ }
+
+ function safeMint(address to, uint256 tokenId, bytes memory data) external {
+ _safeMint(to, tokenId, data);
+ }
+
+ function burn(uint256 tokenId) external {
+ _burn(tokenId);
+ }
+
+ function unsafeOwnerOf(uint256 tokenId) external view returns (address) {
+ return _ownerOf(tokenId);
+ }
+
+ function unsafeGetApproved(uint256 tokenId) external view returns (address) {
+ return _getApproved(tokenId);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/ERC721ReceiverHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/ERC721ReceiverHarness.sol
new file mode 100644
index 000000000..3843ef4a2
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/ERC721ReceiverHarness.sol
@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import "../patched/interfaces/IERC721Receiver.sol";
+
+contract ERC721ReceiverHarness is IERC721Receiver {
+ function onERC721Received(address, address, uint256, bytes calldata) external pure returns (bytes4) {
+ return this.onERC721Received.selector;
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/EnumerableMapHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/EnumerableMapHarness.sol
new file mode 100644
index 000000000..6155193e9
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/EnumerableMapHarness.sol
@@ -0,0 +1,55 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {EnumerableMap} from "../patched/utils/structs/EnumerableMap.sol";
+
+contract EnumerableMapHarness {
+ using EnumerableMap for EnumerableMap.Bytes32ToBytes32Map;
+
+ EnumerableMap.Bytes32ToBytes32Map private _map;
+
+ function set(bytes32 key, bytes32 value) public returns (bool) {
+ return _map.set(key, value);
+ }
+
+ function remove(bytes32 key) public returns (bool) {
+ return _map.remove(key);
+ }
+
+ function contains(bytes32 key) public view returns (bool) {
+ return _map.contains(key);
+ }
+
+ function length() public view returns (uint256) {
+ return _map.length();
+ }
+
+ function key_at(uint256 index) public view returns (bytes32) {
+ (bytes32 key,) = _map.at(index);
+ return key;
+ }
+
+ function value_at(uint256 index) public view returns (bytes32) {
+ (,bytes32 value) = _map.at(index);
+ return value;
+ }
+
+ function tryGet_contains(bytes32 key) public view returns (bool) {
+ (bool contained,) = _map.tryGet(key);
+ return contained;
+ }
+
+ function tryGet_value(bytes32 key) public view returns (bytes32) {
+ (,bytes32 value) = _map.tryGet(key);
+ return value;
+ }
+
+ function get(bytes32 key) public view returns (bytes32) {
+ return _map.get(key);
+ }
+
+ function _positionOf(bytes32 key) public view returns (uint256) {
+ return _map._keys._inner._positions[key];
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/EnumerableSetHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/EnumerableSetHarness.sol
new file mode 100644
index 000000000..09246de6b
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/EnumerableSetHarness.sol
@@ -0,0 +1,35 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.20;
+
+import {EnumerableSet} from "../patched/utils/structs/EnumerableSet.sol";
+
+contract EnumerableSetHarness {
+ using EnumerableSet for EnumerableSet.Bytes32Set;
+
+ EnumerableSet.Bytes32Set private _set;
+
+ function add(bytes32 value) public returns (bool) {
+ return _set.add(value);
+ }
+
+ function remove(bytes32 value) public returns (bool) {
+ return _set.remove(value);
+ }
+
+ function contains(bytes32 value) public view returns (bool) {
+ return _set.contains(value);
+ }
+
+ function length() public view returns (uint256) {
+ return _set.length();
+ }
+
+ function at_(uint256 index) public view returns (bytes32) {
+ return _set.at(index);
+ }
+
+ function _positionOf(bytes32 value) public view returns (uint256) {
+ return _set._inner._positions[value];
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/InitializableHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/InitializableHarness.sol
new file mode 100644
index 000000000..743d677dd
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/InitializableHarness.sol
@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Initializable} from "../patched/proxy/utils/Initializable.sol";
+
+contract InitializableHarness is Initializable {
+ function initialize() public initializer {}
+ function reinitialize(uint64 n) public reinitializer(n) {}
+ function disable() public { _disableInitializers(); }
+
+ function nested_init_init() public initializer { initialize(); }
+ function nested_init_reinit(uint64 m) public initializer { reinitialize(m); }
+ function nested_reinit_init(uint64 n) public reinitializer(n) { initialize(); }
+ function nested_reinit_reinit(uint64 n, uint64 m) public reinitializer(n) { reinitialize(m); }
+
+ function version() public view returns (uint64) {
+ return _getInitializedVersion();
+ }
+
+ function initializing() public view returns (bool) {
+ return _isInitializing();
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/NoncesHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/NoncesHarness.sol
new file mode 100644
index 000000000..beea5fdab
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/NoncesHarness.sol
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Nonces} from "../patched/utils/Nonces.sol";
+
+contract NoncesHarness is Nonces {
+ function useNonce(address account) external returns (uint256) {
+ return _useNonce(account);
+ }
+
+ function useCheckedNonce(address account, uint256 nonce) external {
+ _useCheckedNonce(account, nonce);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/Ownable2StepHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/Ownable2StepHarness.sol
new file mode 100644
index 000000000..09a5faa23
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/Ownable2StepHarness.sol
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Ownable2Step, Ownable} from "../patched/access/Ownable2Step.sol";
+
+contract Ownable2StepHarness is Ownable2Step {
+ constructor(address initialOwner) Ownable(initialOwner) {}
+
+ function restricted() external onlyOwner {}
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/OwnableHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/OwnableHarness.sol
new file mode 100644
index 000000000..79b4b1b6c
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/OwnableHarness.sol
@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Ownable} from "../patched/access/Ownable.sol";
+
+contract OwnableHarness is Ownable {
+ constructor(address initialOwner) Ownable(initialOwner) {}
+
+ function restricted() external onlyOwner {}
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/PausableHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/PausableHarness.sol
new file mode 100644
index 000000000..5977b9202
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/PausableHarness.sol
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {Pausable} from "../patched/utils/Pausable.sol";
+
+contract PausableHarness is Pausable {
+ function pause() external {
+ _pause();
+ }
+
+ function unpause() external {
+ _unpause();
+ }
+
+ function onlyWhenPaused() external whenPaused {}
+
+ function onlyWhenNotPaused() external whenNotPaused {}
+}
diff --git a/con/lib/openzeppelin-contracts/certora/harnesses/TimelockControllerHarness.sol b/con/lib/openzeppelin-contracts/certora/harnesses/TimelockControllerHarness.sol
new file mode 100644
index 000000000..95ae40621
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/harnesses/TimelockControllerHarness.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.20;
+
+import {TimelockController} from "../patched/governance/TimelockController.sol";
+
+contract TimelockControllerHarness is TimelockController {
+ constructor(
+ uint256 minDelay,
+ address[] memory proposers,
+ address[] memory executors,
+ address admin
+ ) TimelockController(minDelay, proposers, executors, admin) {}
+}
diff --git a/con/lib/openzeppelin-contracts/certora/reports/2021-10.pdf b/con/lib/openzeppelin-contracts/certora/reports/2021-10.pdf
new file mode 100644
index 000000000..22df9c61e
Binary files /dev/null and b/con/lib/openzeppelin-contracts/certora/reports/2021-10.pdf differ
diff --git a/con/lib/openzeppelin-contracts/certora/reports/2022-03.pdf b/con/lib/openzeppelin-contracts/certora/reports/2022-03.pdf
new file mode 100644
index 000000000..b6ff81d18
Binary files /dev/null and b/con/lib/openzeppelin-contracts/certora/reports/2022-03.pdf differ
diff --git a/con/lib/openzeppelin-contracts/certora/reports/2022-05.pdf b/con/lib/openzeppelin-contracts/certora/reports/2022-05.pdf
new file mode 100644
index 000000000..f24a44910
Binary files /dev/null and b/con/lib/openzeppelin-contracts/certora/reports/2022-05.pdf differ
diff --git a/con/lib/openzeppelin-contracts/certora/run.js b/con/lib/openzeppelin-contracts/certora/run.js
new file mode 100755
index 000000000..91f4a6aec
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/run.js
@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+
+// USAGE:
+// node certora/run.js [[CONTRACT_NAME:]SPEC_NAME]* [--all] [--options OPTIONS...] [--specs PATH]
+// EXAMPLES:
+// node certora/run.js --all
+// node certora/run.js AccessControl
+// node certora/run.js AccessControlHarness:AccessControl
+
+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 = yargs(hideBin(process.argv))
+ .env('')
+ .options({
+ all: {
+ alias: 'a',
+ type: 'boolean',
+ },
+ spec: {
+ alias: 's',
+ type: 'string',
+ default: path.resolve(import.meta.dirname, 'specs.json'),
+ },
+ parallel: {
+ alias: 'p',
+ type: 'number',
+ default: 4,
+ },
+ verbose: {
+ alias: 'v',
+ type: 'count',
+ default: 0,
+ },
+ options: {
+ alias: 'o',
+ type: 'array',
+ default: [],
+ },
+ })
+ .parse();
+
+function match(entry, request) {
+ const [reqSpec, reqContract] = request.split(':').reverse();
+ return entry.spec == reqSpec && (!reqContract || entry.contract == reqContract);
+}
+
+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 forget to toggle '--all'?`);
+}
+
+for (const r of argv._) {
+ if (!specs.some(s => match(s, r))) {
+ console.error(`Error: Requested spec '${r}' not found in ${argv.spec}`);
+ process.exitCode = 1;
+ }
+}
+
+if (process.exitCode) {
+ process.exit(process.exitCode);
+}
+
+for (const { spec, contract, files, options = [] } of specs) {
+ limit(() =>
+ runCertora(
+ spec,
+ contract,
+ files,
+ [...options, ...argv.options].flatMap(opt => opt.split(' ')),
+ ),
+ );
+}
+
+// Run certora, aggregate the output and print it at the end
+async function runCertora(spec, contract, files, options = []) {
+ const args = [...files, '--verify', `${contract}:certora/specs/${spec}.spec`, ...options];
+ if (argv.verbose) {
+ console.log('Running:', args.join(' '));
+ }
+ const child = spawn('certoraRun', args);
+
+ const stream = new PassThrough();
+ const output = collect(stream);
+
+ child.stdout.pipe(stream, { end: false });
+ child.stderr.pipe(stream, { end: false });
+
+ // as soon as we have a job id, print the output link
+ stream.on('data', function logStatusUrl(data) {
+ const { '-DjobId': jobId, '-DuserId': userId } = Object.fromEntries(
+ data
+ .toString('utf8')
+ .match(/-D\S+=\S+/g)
+ ?.map(s => s.split('=')) || [],
+ );
+
+ if (jobId && userId) {
+ console.error(`[${spec}] https://prover.certora.com/output/${userId}/${jobId}/`);
+ stream.off('data', logStatusUrl);
+ }
+ });
+
+ // wait for process end
+ const [code, signal] = await once(child, 'exit');
+
+ // error
+ if (code || signal) {
+ console.error(`[${spec}] Exited with code ${code || signal}`);
+ process.exitCode = 1;
+ }
+
+ // get all output
+ stream.end();
+
+ // write results in markdown format
+ writeEntry(spec, contract, code || signal, (await output).match(/https:\/\/prover.certora.com\/output\/\S*/)?.[0]);
+
+ // write all details
+ console.error(`+ certoraRun ${args.join(' ')}\n` + (await output));
+}
+
+// Collects stream data into a string
+async function collect(stream) {
+ const buffers = [];
+ for await (const data of stream) {
+ const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+ buffers.push(buf);
+ }
+ return Buffer.concat(buffers).toString('utf8');
+}
+
+// Formatting
+let hasHeader = false;
+
+function formatRow(...array) {
+ return ['', ...array, ''].join(' | ');
+}
+
+function writeHeader() {
+ console.log(formatRow('spec', 'contract', 'result', 'status', 'output'));
+ console.log(formatRow('-', '-', '-', '-', '-'));
+}
+
+function writeEntry(spec, contract, success, url) {
+ if (!hasHeader) {
+ hasHeader = true;
+ writeHeader();
+ }
+ console.log(
+ formatRow(
+ spec,
+ contract,
+ success ? ':heavy_check_mark:' : ':x:',
+ url ? `[link](${url?.replace('/output/', '/jobStatus/')})` : 'error',
+ url ? `[link](${url})` : 'error',
+ ),
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs.json b/con/lib/openzeppelin-contracts/certora/specs.json
new file mode 100644
index 000000000..a89419092
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs.json
@@ -0,0 +1,110 @@
+[
+ {
+ "spec": "Pausable",
+ "contract": "PausableHarness",
+ "files": ["certora/harnesses/PausableHarness.sol"]
+ },
+ {
+ "spec": "AccessControl",
+ "contract": "AccessControlHarness",
+ "files": ["certora/harnesses/AccessControlHarness.sol"]
+ },
+ {
+ "spec": "AccessControlDefaultAdminRules",
+ "contract": "AccessControlDefaultAdminRulesHarness",
+ "files": ["certora/harnesses/AccessControlDefaultAdminRulesHarness.sol"]
+ },
+ {
+ "spec": "AccessManager",
+ "contract": "AccessManagerHarness",
+ "files": ["certora/harnesses/AccessManagerHarness.sol"],
+ "options": ["--optimistic_hashing", "--optimistic_loop"]
+ },
+ {
+ "spec": "AccessManaged",
+ "contract": "AccessManagedHarness",
+ "files": [
+ "certora/harnesses/AccessManagedHarness.sol",
+ "certora/harnesses/AccessManagerHarness.sol"
+ ],
+ "options": [
+ "--optimistic_hashing",
+ "--optimistic_loop",
+ "--link AccessManagedHarness:_authority=AccessManagerHarness"
+ ]
+ },
+ {
+ "spec": "DoubleEndedQueue",
+ "contract": "DoubleEndedQueueHarness",
+ "files": ["certora/harnesses/DoubleEndedQueueHarness.sol"]
+ },
+ {
+ "spec": "Ownable",
+ "contract": "OwnableHarness",
+ "files": ["certora/harnesses/OwnableHarness.sol"]
+ },
+ {
+ "spec": "Ownable2Step",
+ "contract": "Ownable2StepHarness",
+ "files": ["certora/harnesses/Ownable2StepHarness.sol"]
+ },
+ {
+ "spec": "ERC20",
+ "contract": "ERC20PermitHarness",
+ "files": ["certora/harnesses/ERC20PermitHarness.sol"],
+ "options": ["--optimistic_loop"]
+ },
+ {
+ "spec": "ERC20FlashMint",
+ "contract": "ERC20FlashMintHarness",
+ "files": [
+ "certora/harnesses/ERC20FlashMintHarness.sol",
+ "certora/harnesses/ERC3156FlashBorrowerHarness.sol"
+ ],
+ "options": ["--optimistic_loop"]
+ },
+ {
+ "spec": "ERC20Wrapper",
+ "contract": "ERC20WrapperHarness",
+ "files": [
+ "certora/harnesses/ERC20PermitHarness.sol",
+ "certora/harnesses/ERC20WrapperHarness.sol"
+ ],
+ "options": [
+ "--link ERC20WrapperHarness:_underlying=ERC20PermitHarness",
+ "--optimistic_loop"
+ ]
+ },
+ {
+ "spec": "ERC721",
+ "contract": "ERC721Harness",
+ "files": ["certora/harnesses/ERC721Harness.sol", "certora/harnesses/ERC721ReceiverHarness.sol"],
+ "options": ["--optimistic_loop"]
+ },
+ {
+ "spec": "Initializable",
+ "contract": "InitializableHarness",
+ "files": ["certora/harnesses/InitializableHarness.sol"]
+ },
+ {
+ "spec": "EnumerableSet",
+ "contract": "EnumerableSetHarness",
+ "files": ["certora/harnesses/EnumerableSetHarness.sol"]
+ },
+ {
+ "spec": "EnumerableMap",
+ "contract": "EnumerableMapHarness",
+ "files": ["certora/harnesses/EnumerableMapHarness.sol"]
+ },
+ {
+ "spec": "TimelockController",
+ "contract": "TimelockControllerHarness",
+ "files": ["certora/harnesses/TimelockControllerHarness.sol"],
+ "options": ["--optimistic_hashing", "--optimistic_loop"]
+ },
+ {
+ "spec": "Nonces",
+ "contract": "NoncesHarness",
+ "files": ["certora/harnesses/NoncesHarness.sol"]
+ }
+]
diff --git a/con/lib/openzeppelin-contracts/certora/specs/AccessControl.spec b/con/lib/openzeppelin-contracts/certora/specs/AccessControl.spec
new file mode 100644
index 000000000..70b067218
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/AccessControl.spec
@@ -0,0 +1,119 @@
+import "helpers/helpers.spec";
+import "methods/IAccessControl.spec";
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Identify entrypoints: only grantRole, revokeRole and renounceRole can alter permissions โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyGrantCanGrant(env e, method f, bytes32 role, address account) {
+ calldataarg args;
+
+ bool hasRoleBefore = hasRole(role, account);
+ f(e, args);
+ bool hasRoleAfter = hasRole(role, account);
+
+ assert (
+ !hasRoleBefore &&
+ hasRoleAfter
+ ) => (
+ f.selector == sig:grantRole(bytes32, address).selector
+ );
+
+ assert (
+ hasRoleBefore &&
+ !hasRoleAfter
+ ) => (
+ f.selector == sig:revokeRole(bytes32, address).selector ||
+ f.selector == sig:renounceRole(bytes32, address).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: grantRole only affects the specified user/role combo โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule grantRoleEffect(env e, bytes32 role) {
+ require nonpayable(e);
+
+ bytes32 otherRole;
+ address account;
+ address otherAccount;
+
+ bool isCallerAdmin = hasRole(getRoleAdmin(role), e.msg.sender);
+ bool hasOtherRoleBefore = hasRole(otherRole, otherAccount);
+
+ grantRole@withrevert(e, role, account);
+ bool success = !lastReverted;
+
+ bool hasOtherRoleAfter = hasRole(otherRole, otherAccount);
+
+ // liveness
+ assert success <=> isCallerAdmin;
+
+ // effect
+ assert success => hasRole(role, account);
+
+ // no side effect
+ assert hasOtherRoleBefore != hasOtherRoleAfter => (role == otherRole && account == otherAccount);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: revokeRole only affects the specified user/role combo โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule revokeRoleEffect(env e, bytes32 role) {
+ require nonpayable(e);
+
+ bytes32 otherRole;
+ address account;
+ address otherAccount;
+
+ bool isCallerAdmin = hasRole(getRoleAdmin(role), e.msg.sender);
+ bool hasOtherRoleBefore = hasRole(otherRole, otherAccount);
+
+ revokeRole@withrevert(e, role, account);
+ bool success = !lastReverted;
+
+ bool hasOtherRoleAfter = hasRole(otherRole, otherAccount);
+
+ // liveness
+ assert success <=> isCallerAdmin;
+
+ // effect
+ assert success => !hasRole(role, account);
+
+ // no side effect
+ assert hasOtherRoleBefore != hasOtherRoleAfter => (role == otherRole && account == otherAccount);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: renounceRole only affects the specified user/role combo โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule renounceRoleEffect(env e, bytes32 role) {
+ require nonpayable(e);
+
+ bytes32 otherRole;
+ address account;
+ address otherAccount;
+
+ bool hasOtherRoleBefore = hasRole(otherRole, otherAccount);
+
+ renounceRole@withrevert(e, role, account);
+ bool success = !lastReverted;
+
+ bool hasOtherRoleAfter = hasRole(otherRole, otherAccount);
+
+ // liveness
+ assert success <=> account == e.msg.sender;
+
+ // effect
+ assert success => !hasRole(role, account);
+
+ // no side effect
+ assert hasOtherRoleBefore != hasOtherRoleAfter => (role == otherRole && account == otherAccount);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/AccessControlDefaultAdminRules.spec b/con/lib/openzeppelin-contracts/certora/specs/AccessControlDefaultAdminRules.spec
new file mode 100644
index 000000000..5860fd564
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/AccessControlDefaultAdminRules.spec
@@ -0,0 +1,464 @@
+import "helpers/helpers.spec";
+import "methods/IAccessControlDefaultAdminRules.spec";
+import "methods/IAccessControl.spec";
+import "AccessControl.spec";
+
+use rule onlyGrantCanGrant filtered {
+ f -> f.selector != sig:acceptDefaultAdminTransfer().selector
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Definitions โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition timeSanity(env e) returns bool =
+ e.block.timestamp > 0 && e.block.timestamp + defaultAdminDelay(e) < max_uint48;
+
+definition delayChangeWaitSanity(env e, uint48 newDelay) returns bool =
+ e.block.timestamp + delayChangeWait_(e, newDelay) < max_uint48;
+
+definition isSet(uint48 schedule) returns bool =
+ schedule != 0;
+
+definition hasPassed(env e, uint48 schedule) returns bool =
+ assert_uint256(schedule) < e.block.timestamp;
+
+definition increasingDelaySchedule(env e, uint48 newDelay) returns mathint =
+ e.block.timestamp + min(newDelay, defaultAdminDelayIncreaseWait());
+
+definition decreasingDelaySchedule(env e, uint48 newDelay) returns mathint =
+ e.block.timestamp + defaultAdminDelay(e) - newDelay;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: defaultAdmin holds the DEFAULT_ADMIN_ROLE โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant defaultAdminConsistency(address account)
+ (account == defaultAdmin() && account != 0) <=> hasRole(DEFAULT_ADMIN_ROLE(), account)
+ {
+ preserved with (env e) {
+ require nonzerosender(e);
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: Only one account holds the DEFAULT_ADMIN_ROLE โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant singleDefaultAdmin(address account, address another)
+ hasRole(DEFAULT_ADMIN_ROLE(), account) && hasRole(DEFAULT_ADMIN_ROLE(), another) => another == account
+ {
+ preserved {
+ requireInvariant defaultAdminConsistency(account);
+ requireInvariant defaultAdminConsistency(another);
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: DEFAULT_ADMIN_ROLE's admin is always DEFAULT_ADMIN_ROLE โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant defaultAdminRoleAdminConsistency()
+ getRoleAdmin(DEFAULT_ADMIN_ROLE()) == DEFAULT_ADMIN_ROLE();
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: owner is the defaultAdmin โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant ownerConsistency()
+ defaultAdmin() == owner();
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: revokeRole only affects the specified user/role combo โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule revokeRoleEffect(env e, bytes32 role) {
+ require nonpayable(e);
+
+ bytes32 otherRole;
+ address account;
+ address otherAccount;
+
+ bool isCallerAdmin = hasRole(getRoleAdmin(role), e.msg.sender);
+ bool hasOtherRoleBefore = hasRole(otherRole, otherAccount);
+
+ revokeRole@withrevert(e, role, account);
+ bool success = !lastReverted;
+
+ bool hasOtherRoleAfter = hasRole(otherRole, otherAccount);
+
+ // liveness
+ assert success <=> isCallerAdmin && role != DEFAULT_ADMIN_ROLE(),
+ "roles can only be revoked by their owner except for the default admin role";
+
+ // effect
+ assert success => !hasRole(role, account),
+ "role is revoked";
+
+ // no side effect
+ assert hasOtherRoleBefore != hasOtherRoleAfter => (role == otherRole && account == otherAccount),
+ "no other role is affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: renounceRole only affects the specified user/role combo โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule renounceRoleEffect(env e, bytes32 role) {
+ require nonpayable(e);
+
+ bytes32 otherRole;
+ address account;
+ address otherAccount;
+
+ bool hasOtherRoleBefore = hasRole(otherRole, otherAccount);
+ address adminBefore = defaultAdmin();
+ address pendingAdminBefore = pendingDefaultAdmin_();
+ uint48 scheduleBefore = pendingDefaultAdminSchedule_();
+
+ renounceRole@withrevert(e, role, account);
+ bool success = !lastReverted;
+
+ bool hasOtherRoleAfter = hasRole(otherRole, otherAccount);
+ address adminAfter = defaultAdmin();
+ address pendingAdminAfter = pendingDefaultAdmin_();
+ uint48 scheduleAfter = pendingDefaultAdminSchedule_();
+
+ // liveness
+ assert success <=> (
+ account == e.msg.sender &&
+ (
+ role != DEFAULT_ADMIN_ROLE() ||
+ account != adminBefore ||
+ (
+ pendingAdminBefore == 0 &&
+ isSet(scheduleBefore) &&
+ hasPassed(e, scheduleBefore)
+ )
+ )
+ ),
+ "an account only can renounce by itself with a delay for the default admin role";
+
+ // effect
+ assert success => !hasRole(role, account),
+ "role is renounced";
+
+ assert success => (
+ (
+ role == DEFAULT_ADMIN_ROLE() &&
+ account == adminBefore
+ ) ? (
+ adminAfter == 0 &&
+ pendingAdminAfter == 0 &&
+ scheduleAfter == 0
+ ) : (
+ adminAfter == adminBefore &&
+ pendingAdminAfter == pendingAdminBefore &&
+ scheduleAfter == scheduleBefore
+ )
+ ),
+ "renouncing default admin role cleans state iff called by previous admin";
+
+ // no side effect
+ assert hasOtherRoleBefore != hasOtherRoleAfter => (
+ role == otherRole &&
+ account == otherAccount
+ ),
+ "no other role is affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: defaultAdmin is only affected by accepting an admin transfer or renouncing โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noDefaultAdminChange(env e, method f, calldataarg args) {
+ address adminBefore = defaultAdmin();
+ f(e, args);
+ address adminAfter = defaultAdmin();
+
+ assert adminBefore != adminAfter => (
+ f.selector == sig:acceptDefaultAdminTransfer().selector ||
+ f.selector == sig:renounceRole(bytes32,address).selector
+ ),
+ "default admin is only affected by accepting an admin transfer or renouncing";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: pendingDefaultAdmin is only affected by beginning, completing (accept or renounce), or canceling an admin โ
+โ transfer โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noPendingDefaultAdminChange(env e, method f, calldataarg args) {
+ address pendingAdminBefore = pendingDefaultAdmin_();
+ uint48 scheduleBefore = pendingDefaultAdminSchedule_();
+ f(e, args);
+ address pendingAdminAfter = pendingDefaultAdmin_();
+ uint48 scheduleAfter = pendingDefaultAdminSchedule_();
+
+ assert (
+ pendingAdminBefore != pendingAdminAfter ||
+ scheduleBefore != scheduleAfter
+ ) => (
+ f.selector == sig:beginDefaultAdminTransfer(address).selector ||
+ f.selector == sig:acceptDefaultAdminTransfer().selector ||
+ f.selector == sig:cancelDefaultAdminTransfer().selector ||
+ f.selector == sig:renounceRole(bytes32,address).selector
+ ),
+ "pending admin and its schedule is only affected by beginning, completing, or cancelling an admin transfer";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: defaultAdminDelay can't be changed atomically by any function โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noDefaultAdminDelayChange(env e, method f, calldataarg args) {
+ uint48 delayBefore = defaultAdminDelay(e);
+ f(e, args);
+ uint48 delayAfter = defaultAdminDelay(e);
+
+ assert delayBefore == delayAfter,
+ "delay can't be changed atomically by any function";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: pendingDefaultAdminDelay is only affected by changeDefaultAdminDelay or rollbackDefaultAdminDelay โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noPendingDefaultAdminDelayChange(env e, method f, calldataarg args) {
+ uint48 pendingDelayBefore = pendingDelay_(e);
+ f(e, args);
+ uint48 pendingDelayAfter = pendingDelay_(e);
+
+ assert pendingDelayBefore != pendingDelayAfter => (
+ f.selector == sig:changeDefaultAdminDelay(uint48).selector ||
+ f.selector == sig:rollbackDefaultAdminDelay().selector
+ ),
+ "pending delay is only affected by changeDefaultAdminDelay or rollbackDefaultAdminDelay";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: defaultAdminDelayIncreaseWait can't be changed atomically by any function โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noDefaultAdminDelayIncreaseWaitChange(env e, method f, calldataarg args) {
+ uint48 delayIncreaseWaitBefore = defaultAdminDelayIncreaseWait();
+ f(e, args);
+ uint48 delayIncreaseWaitAfter = defaultAdminDelayIncreaseWait();
+
+ assert delayIncreaseWaitBefore == delayIncreaseWaitAfter,
+ "delay increase wait can't be changed atomically by any function";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: beginDefaultAdminTransfer sets a pending default admin and its schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule beginDefaultAdminTransfer(env e, address newAdmin) {
+ require timeSanity(e);
+ require nonpayable(e);
+ require nonzerosender(e);
+ requireInvariant defaultAdminConsistency(e.msg.sender);
+
+ beginDefaultAdminTransfer@withrevert(e, newAdmin);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> e.msg.sender == defaultAdmin(),
+ "only the current default admin can begin a transfer";
+
+ // effect
+ assert success => pendingDefaultAdmin_() == newAdmin,
+ "pending default admin is set";
+ assert success => to_mathint(pendingDefaultAdminSchedule_()) == e.block.timestamp + defaultAdminDelay(e),
+ "pending default admin delay is set";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: A default admin can't change in less than the applied schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pendingDefaultAdminDelayEnforced(env e1, env e2, method f, calldataarg args, address newAdmin) {
+ require e1.block.timestamp <= e2.block.timestamp;
+
+ uint48 delayBefore = defaultAdminDelay(e1);
+ address adminBefore = defaultAdmin();
+
+ // There might be a better way to generalize this without requiring `beginDefaultAdminTransfer`, but currently
+ // it's the only way in which we can attest that only `delayBefore` has passed before a change.
+ beginDefaultAdminTransfer(e1, newAdmin);
+ f(e2, args);
+
+ address adminAfter = defaultAdmin();
+
+ // change can only happen towards the newAdmin, with the delay
+ assert adminAfter != adminBefore => (
+ adminAfter == newAdmin &&
+ to_mathint(e2.block.timestamp) >= e1.block.timestamp + delayBefore
+ ),
+ "The admin can only change after the enforced delay and to the previously scheduled new admin";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: acceptDefaultAdminTransfer updates defaultAdmin resetting the pending admin and its schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule acceptDefaultAdminTransfer(env e) {
+ require nonpayable(e);
+
+ address pendingAdminBefore = pendingDefaultAdmin_();
+ uint48 scheduleBefore = pendingDefaultAdminSchedule_();
+
+ acceptDefaultAdminTransfer@withrevert(e);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ e.msg.sender == pendingAdminBefore &&
+ isSet(scheduleBefore) &&
+ hasPassed(e, scheduleBefore)
+ ),
+ "only the pending default admin can accept the role after the schedule has been set and passed";
+
+ // effect
+ assert success => defaultAdmin() == pendingAdminBefore,
+ "Default admin is set to the previous pending default admin";
+ assert success => pendingDefaultAdmin_() == 0,
+ "Pending default admin is reset";
+ assert success => pendingDefaultAdminSchedule_() == 0,
+ "Pending default admin delay is reset";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: cancelDefaultAdminTransfer resets pending default admin and its schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule cancelDefaultAdminTransfer(env e) {
+ require nonpayable(e);
+ require nonzerosender(e);
+ requireInvariant defaultAdminConsistency(e.msg.sender);
+
+ cancelDefaultAdminTransfer@withrevert(e);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> e.msg.sender == defaultAdmin(),
+ "only the current default admin can cancel a transfer";
+
+ // effect
+ assert success => pendingDefaultAdmin_() == 0,
+ "Pending default admin is reset";
+ assert success => pendingDefaultAdminSchedule_() == 0,
+ "Pending default admin delay is reset";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: changeDefaultAdminDelay sets a pending default admin delay and its schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule changeDefaultAdminDelay(env e, uint48 newDelay) {
+ require timeSanity(e);
+ require nonpayable(e);
+ require nonzerosender(e);
+ require delayChangeWaitSanity(e, newDelay);
+ requireInvariant defaultAdminConsistency(e.msg.sender);
+
+ uint48 delayBefore = defaultAdminDelay(e);
+
+ changeDefaultAdminDelay@withrevert(e, newDelay);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> e.msg.sender == defaultAdmin(),
+ "only the current default admin can begin a delay change";
+
+ // effect
+ assert success => pendingDelay_(e) == newDelay,
+ "pending delay is set";
+
+ assert success => (
+ assert_uint256(pendingDelaySchedule_(e)) > e.block.timestamp ||
+ delayBefore == newDelay || // Interpreted as decreasing, x - x = 0
+ defaultAdminDelayIncreaseWait() == 0
+ ),
+ "pending delay schedule is set in the future unless accepted edge cases";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: A delay can't change in less than the applied schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pendingDelayWaitEnforced(env e1, env e2, method f, calldataarg args, uint48 newDelay) {
+ require e1.block.timestamp <= e2.block.timestamp;
+
+ uint48 delayBefore = defaultAdminDelay(e1);
+
+ changeDefaultAdminDelay(e1, newDelay);
+ f(e2, args);
+
+ uint48 delayAfter = defaultAdminDelay(e2);
+
+ mathint delayWait = newDelay > delayBefore ? increasingDelaySchedule(e1, newDelay) : decreasingDelaySchedule(e1, newDelay);
+
+ assert delayAfter != delayBefore => (
+ delayAfter == newDelay &&
+ to_mathint(e2.block.timestamp) >= delayWait
+ ),
+ "A delay can only change after the applied schedule";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: pending delay wait is set depending on increasing or decreasing the delay โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pendingDelayWait(env e, uint48 newDelay) {
+ uint48 oldDelay = defaultAdminDelay(e);
+ changeDefaultAdminDelay(e, newDelay);
+
+ assert newDelay > oldDelay => to_mathint(pendingDelaySchedule_(e)) == increasingDelaySchedule(e, newDelay),
+ "Delay wait is the minimum between the new delay and a threshold when the delay is increased";
+ assert newDelay <= oldDelay => to_mathint(pendingDelaySchedule_(e)) == decreasingDelaySchedule(e, newDelay),
+ "Delay wait is the difference between the current and the new delay when the delay is decreased";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: rollbackDefaultAdminDelay resets the delay and its schedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule rollbackDefaultAdminDelay(env e) {
+ require nonpayable(e);
+ require nonzerosender(e);
+ requireInvariant defaultAdminConsistency(e.msg.sender);
+
+ rollbackDefaultAdminDelay@withrevert(e);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> e.msg.sender == defaultAdmin(),
+ "only the current default admin can rollback a delay change";
+
+ // effect
+ assert success => pendingDelay_(e) == 0,
+ "Pending default admin is reset";
+ assert success => pendingDelaySchedule_(e) == 0,
+ "Pending default admin delay is reset";
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/AccessManaged.spec b/con/lib/openzeppelin-contracts/certora/specs/AccessManaged.spec
new file mode 100644
index 000000000..adcb85936
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/AccessManaged.spec
@@ -0,0 +1,34 @@
+import "helpers/helpers.spec";
+import "methods/IAccessManaged.spec";
+
+methods {
+ // FV
+ function someFunction() external;
+ function authority_canCall_immediate(address) external returns (bool);
+ function authority_canCall_delay(address) external returns (uint32);
+ function authority_getSchedule(address) external returns (uint48);
+}
+
+invariant isConsumingScheduledOpClean()
+ isConsumingScheduledOp() == to_bytes4(0);
+
+rule callRestrictedFunction(env e) {
+ bool immediate = authority_canCall_immediate(e, e.msg.sender);
+ uint32 delay = authority_canCall_delay(e, e.msg.sender);
+ uint48 scheduleBefore = authority_getSchedule(e, e.msg.sender);
+
+ someFunction@withrevert(e);
+ bool success = !lastReverted;
+
+ uint48 scheduleAfter = authority_getSchedule(e, e.msg.sender);
+
+ // can only call if immediate, or (with delay) by consuming a scheduled op
+ assert success => (
+ immediate ||
+ (
+ delay > 0 &&
+ isSetAndPast(e, scheduleBefore) &&
+ scheduleAfter == 0
+ )
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/AccessManager.spec b/con/lib/openzeppelin-contracts/certora/specs/AccessManager.spec
new file mode 100644
index 000000000..cc4b0132a
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/AccessManager.spec
@@ -0,0 +1,826 @@
+import "helpers/helpers.spec";
+import "methods/IAccessManager.spec";
+
+methods {
+ // FV
+ function canCall_immediate(address,address,bytes4) external returns (bool);
+ function canCall_delay(address,address,bytes4) external returns (uint32);
+ function canCallExtended(address,address,bytes) external returns (bool,uint32);
+ function canCallExtended_immediate(address,address,bytes) external returns (bool);
+ function canCallExtended_delay(address,address,bytes) external returns (uint32);
+ function getAdminRestrictions_restricted(bytes) external returns (bool);
+ function getAdminRestrictions_roleAdminId(bytes) external returns (uint64);
+ function getAdminRestrictions_executionDelay(bytes) external returns (uint32);
+ function hasRole_isMember(uint64,address) external returns (bool);
+ function hasRole_executionDelay(uint64,address) external returns (uint32);
+ function getAccess_since(uint64,address) external returns (uint48);
+ function getAccess_currentDelay(uint64,address) external returns (uint32);
+ function getAccess_pendingDelay(uint64,address) external returns (uint32);
+ function getAccess_effect(uint64,address) external returns (uint48);
+ function getTargetAdminDelay_after(address target) external returns (uint32);
+ function getTargetAdminDelay_effect(address target) external returns (uint48);
+ function getRoleGrantDelay_after(uint64 roleId) external returns (uint32);
+ function getRoleGrantDelay_effect(uint64 roleId) external returns (uint48);
+ function hashExecutionId(address,bytes4) external returns (bytes32) envfree;
+ function executionId() external returns (bytes32) envfree;
+ function getSelector(bytes) external returns (bytes4) envfree;
+ function getFirstArgumentAsAddress(bytes) external returns (address) envfree;
+ function getFirstArgumentAsUint64(bytes) external returns (uint64) envfree;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helpers โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition isOnlyAuthorized(bytes4 selector) returns bool =
+ selector == to_bytes4(sig:labelRole(uint64,string).selector ) ||
+ selector == to_bytes4(sig:setRoleAdmin(uint64,uint64).selector ) ||
+ selector == to_bytes4(sig:setRoleGuardian(uint64,uint64).selector ) ||
+ selector == to_bytes4(sig:setGrantDelay(uint64,uint32).selector ) ||
+ selector == to_bytes4(sig:setTargetAdminDelay(address,uint32).selector ) ||
+ selector == to_bytes4(sig:updateAuthority(address,address).selector ) ||
+ selector == to_bytes4(sig:setTargetClosed(address,bool).selector ) ||
+ selector == to_bytes4(sig:setTargetFunctionRole(address,bytes4[],uint64).selector) ||
+ selector == to_bytes4(sig:grantRole(uint64,address,uint32).selector ) ||
+ selector == to_bytes4(sig:revokeRole(uint64,address).selector );
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: executionId must be clean when not in the middle of a call โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant cleanExecutionId()
+ executionId() == to_bytes32(0);
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: public role โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant publicRole(env e, address account)
+ hasRole_isMember(e, PUBLIC_ROLE(), account) &&
+ hasRole_executionDelay(e, PUBLIC_ROLE(), account) == 0 &&
+ getAccess_since(e, PUBLIC_ROLE(), account) == 0 &&
+ getAccess_currentDelay(e, PUBLIC_ROLE(), account) == 0 &&
+ getAccess_pendingDelay(e, PUBLIC_ROLE(), account) == 0 &&
+ getAccess_effect(e, PUBLIC_ROLE(), account) == 0;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: hasRole is consistent with getAccess โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant hasRoleGetAccessConsistency(env e, uint64 roleId, address account)
+ hasRole_isMember(e, roleId, account) == (roleId == PUBLIC_ROLE() || isSetAndPast(e, getAccess_since(e, roleId, account))) &&
+ hasRole_executionDelay(e, roleId, account) == getAccess_currentDelay(e, roleId, account);
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Functions: canCall, canCallExtended, getAccess, hasRole, isTargetClosed and getTargetFunctionRole do NOT revert โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noRevert(env e) {
+ require nonpayable(e);
+ require sanity(e);
+
+ address caller;
+ address target;
+ bytes data;
+ bytes4 selector;
+ uint64 roleId;
+
+ canCall@withrevert(e, caller, target, selector);
+ assert !lastReverted;
+
+ // require data.length <= max_uint64;
+ //
+ // canCallExtended@withrevert(e, caller, target, data);
+ // assert !lastReverted;
+
+ getAccess@withrevert(e, roleId, caller);
+ assert !lastReverted;
+
+ hasRole@withrevert(e, roleId, caller);
+ assert !lastReverted;
+
+ isTargetClosed@withrevert(target);
+ assert !lastReverted;
+
+ getTargetFunctionRole@withrevert(target, selector);
+ assert !lastReverted;
+
+ // Not covered:
+ // - getAdminRestrictions (_1, _2 & _3)
+ // - getSelector
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Functions: admin restrictions are correct โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getAdminRestrictions(env e, bytes data) {
+ bool restricted = getAdminRestrictions_restricted(e, data);
+ uint64 roleId = getAdminRestrictions_roleAdminId(e, data);
+ uint32 delay = getAdminRestrictions_executionDelay(e, data);
+ bytes4 selector = getSelector(data);
+
+ if (data.length < 4) {
+ assert restricted == false;
+ assert roleId == 0;
+ assert delay == 0;
+ } else {
+ assert restricted ==
+ isOnlyAuthorized(selector);
+
+ assert roleId == (
+ (restricted && selector == to_bytes4(sig:grantRole(uint64,address,uint32).selector)) ||
+ (restricted && selector == to_bytes4(sig:revokeRole(uint64,address).selector ))
+ ? getRoleAdmin(getFirstArgumentAsUint64(data))
+ : ADMIN_ROLE()
+ );
+
+ assert delay == (
+ (restricted && selector == to_bytes4(sig:updateAuthority(address,address).selector )) ||
+ (restricted && selector == to_bytes4(sig:setTargetClosed(address,bool).selector )) ||
+ (restricted && selector == to_bytes4(sig:setTargetFunctionRole(address,bytes4[],uint64).selector))
+ ? getTargetAdminDelay(e, getFirstArgumentAsAddress(data))
+ : 0
+ );
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Functions: canCall โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule canCall(env e) {
+ address caller;
+ address target;
+ bytes4 selector;
+
+ // Get relevant values
+ bool immediate = canCall_immediate(e, caller, target, selector);
+ uint32 delay = canCall_delay(e, caller, target, selector);
+ bool closed = isTargetClosed(target);
+ uint64 roleId = getTargetFunctionRole(target, selector);
+ bool isMember = hasRole_isMember(e, roleId, caller);
+ uint32 currentDelay = hasRole_executionDelay(e, roleId, caller);
+
+ // Can only execute without delay in specific cases:
+ // - target not closed
+ // - if self-execution: `executionId` must match
+ // - if third party execution: must be member with no delay
+ assert immediate <=> (
+ !closed &&
+ (
+ (caller == currentContract && executionId() == hashExecutionId(target, selector))
+ ||
+ (caller != currentContract && isMember && currentDelay == 0)
+ )
+ );
+
+ // Can only execute with delay in specific cases:
+ // - target not closed
+ // - third party execution
+ // - caller is a member and has an execution delay
+ assert delay > 0 <=> (
+ !closed &&
+ caller != currentContract &&
+ isMember &&
+ currentDelay > 0
+ );
+
+ // If there is a delay, then it must be the caller's execution delay
+ assert delay > 0 => delay == currentDelay;
+
+ // Immediate execute means no delayed execution
+ assert immediate => delay == 0;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Functions: canCallExtended โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule canCallExtended(env e) {
+ address caller;
+ address target;
+ bytes data;
+ bytes4 selector = getSelector(data);
+
+ bool immediate = canCallExtended_immediate(e, caller, target, data);
+ uint32 delay = canCallExtended_delay(e, caller, target, data);
+ bool enabled = getAdminRestrictions_restricted(e, data);
+ uint64 roleId = getAdminRestrictions_roleAdminId(e, data);
+ uint32 operationDelay = getAdminRestrictions_executionDelay(e, data);
+ bool inRole = hasRole_isMember(e, roleId, caller);
+ uint32 executionDelay = hasRole_executionDelay(e, roleId, caller);
+
+ if (target == currentContract) {
+ // Can only execute without delay in the specific cases:
+ // - caller is the AccessManager and the executionId is set
+ // or
+ // - data matches an admin restricted function
+ // - caller has the necessary role
+ // - operation delay is not set
+ // - execution delay is not set
+ assert immediate <=> (
+ (
+ caller == currentContract &&
+ data.length >= 4 &&
+ executionId() == hashExecutionId(target, selector)
+ ) || (
+ caller != currentContract &&
+ enabled &&
+ inRole &&
+ operationDelay == 0 &&
+ executionDelay == 0
+ )
+ );
+
+ // Immediate execute means no delayed execution
+ // This is equivalent to "delay > 0 => !immediate"
+ assert immediate => delay == 0;
+
+ // Can only execute with delay in specific cases:
+ // - caller is a third party
+ // - data matches an admin restricted function
+ // - caller has the necessary role
+ // -operation delay or execution delay is set
+ assert delay > 0 <=> (
+ caller != currentContract &&
+ enabled &&
+ inRole &&
+ (operationDelay > 0 || executionDelay > 0)
+ );
+
+ // If there is a delay, then it must be the maximum of caller's execution delay and the operation delay
+ assert delay > 0 => to_mathint(delay) == max(operationDelay, executionDelay);
+ } else if (data.length < 4) {
+ assert immediate == false;
+ assert delay == 0;
+ } else {
+ // results are equivalent when targeting third party contracts
+ assert immediate == canCall_immediate(e, caller, target, selector);
+ assert delay == canCall_delay(e, caller, target, selector);
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getAccess โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getAccessChangeTime(uint64 roleId, address account) {
+ env e1;
+ env e2;
+
+ // values before
+ mathint getAccess1Before = getAccess_since(e1, roleId, account);
+ mathint getAccess2Before = getAccess_currentDelay(e1, roleId, account);
+ mathint getAccess3Before = getAccess_pendingDelay(e1, roleId, account);
+ mathint getAccess4Before = getAccess_effect(e1, roleId, account);
+
+ // time pass: e1 โ e2
+ require clock(e1) <= clock(e2);
+
+ // values after
+ mathint getAccess1After = getAccess_since(e2, roleId, account);
+ mathint getAccess2After = getAccess_currentDelay(e2, roleId, account);
+ mathint getAccess3After = getAccess_pendingDelay(e2, roleId, account);
+ mathint getAccess4After = getAccess_effect(e2, roleId, account);
+
+ // member "since" cannot change as a consequence of time passing
+ assert getAccess1Before == getAccess1After;
+
+ // any change of any other value should be a consequence of the effect timepoint being reached
+ assert (
+ getAccess2Before != getAccess2After ||
+ getAccess3Before != getAccess3After ||
+ getAccess4Before != getAccess4After
+ ) => (
+ getAccess4Before != 0 &&
+ getAccess4Before > clock(e1) &&
+ getAccess4Before <= clock(e2) &&
+ getAccess2After == getAccess3Before &&
+ getAccess3After == 0 &&
+ getAccess4After == 0
+ );
+}
+
+rule getAccessChangeCall(uint64 roleId, address account) {
+ env e;
+
+ // sanity
+ require sanity(e);
+
+ // values before
+ mathint getAccess1Before = getAccess_since(e, roleId, account);
+ mathint getAccess2Before = getAccess_currentDelay(e, roleId, account);
+ mathint getAccess3Before = getAccess_pendingDelay(e, roleId, account);
+ mathint getAccess4Before = getAccess_effect(e, roleId, account);
+
+ // arbitrary function call
+ method f; calldataarg args; f(e, args);
+
+ // values before
+ mathint getAccess1After = getAccess_since(e, roleId, account);
+ mathint getAccess2After = getAccess_currentDelay(e, roleId, account);
+ mathint getAccess3After = getAccess_pendingDelay(e, roleId, account);
+ mathint getAccess4After = getAccess_effect(e, roleId, account);
+
+ // transitions
+ assert (
+ getAccess1Before != getAccess1After ||
+ getAccess2Before != getAccess2After ||
+ getAccess3Before != getAccess3After ||
+ getAccess4Before != getAccess4After
+ ) => (
+ (
+ f.selector == sig:grantRole(uint64,address,uint32).selector &&
+ getAccess1After > 0
+ ) || (
+ (
+ f.selector == sig:revokeRole(uint64,address).selector ||
+ f.selector == sig:renounceRole(uint64,address).selector
+ ) &&
+ getAccess1After == 0 &&
+ getAccess2After == 0 &&
+ getAccess3After == 0 &&
+ getAccess4After == 0
+ )
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: isTargetClosed โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule isTargetClosedChangeTime(address target) {
+ env e1;
+ env e2;
+
+ // values before
+ bool isClosedBefore = isTargetClosed(e1, target);
+
+ // time pass: e1 โ e2
+ require clock(e1) <= clock(e2);
+
+ // values after
+ bool isClosedAfter = isTargetClosed(e2, target);
+
+ // transitions
+ assert isClosedBefore == isClosedAfter;
+}
+
+rule isTargetClosedChangeCall(address target) {
+ env e;
+
+ // values before
+ bool isClosedBefore = isTargetClosed(e, target);
+
+ // arbitrary function call
+ method f; calldataarg args; f(e, args);
+
+ // values after
+ bool isClosedAfter = isTargetClosed(e, target);
+
+ // transitions
+ assert isClosedBefore != isClosedAfter => (
+ f.selector == sig:setTargetClosed(address,bool).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getTargetFunctionRole โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getTargetFunctionRoleChangeTime(address target, bytes4 selector) {
+ env e1;
+ env e2;
+
+ // values before
+ mathint roleIdBefore = getTargetFunctionRole(e1, target, selector);
+
+ // time pass: e1 โ e2
+ require clock(e1) <= clock(e2);
+
+ // values after
+ mathint roleIdAfter = getTargetFunctionRole(e2, target, selector);
+
+ // transitions
+ assert roleIdBefore == roleIdAfter;
+}
+
+rule getTargetFunctionRoleChangeCall(address target, bytes4 selector) {
+ env e;
+
+ // values before
+ mathint roleIdBefore = getTargetFunctionRole(e, target, selector);
+
+ // arbitrary function call
+ method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint roleIdAfter = getTargetFunctionRole(e, target, selector);
+
+ // transitions
+ assert roleIdBefore != roleIdAfter => (
+ f.selector == sig:setTargetFunctionRole(address,bytes4[],uint64).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getTargetAdminDelay โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getTargetAdminDelayChangeTime(address target) {
+ env e1;
+ env e2;
+
+ // values before
+ mathint delayBefore = getTargetAdminDelay(e1, target);
+ mathint delayPendingBefore = getTargetAdminDelay_after(e1, target);
+ mathint delayEffectBefore = getTargetAdminDelay_effect(e1, target);
+
+ // time pass: e1 โ e2
+ require clock(e1) <= clock(e2);
+
+ // values after
+ mathint delayAfter = getTargetAdminDelay(e2, target);
+ mathint delayPendingAfter = getTargetAdminDelay_after(e2, target);
+ mathint delayEffectAfter = getTargetAdminDelay_effect(e2, target);
+
+ assert (
+ delayBefore != delayAfter ||
+ delayPendingBefore != delayPendingAfter ||
+ delayEffectBefore != delayEffectAfter
+ ) => (
+ delayEffectBefore > clock(e1) &&
+ delayEffectBefore <= clock(e2) &&
+ delayAfter == delayPendingBefore &&
+ delayPendingAfter == 0 &&
+ delayEffectAfter == 0
+ );
+}
+
+rule getTargetAdminDelayChangeCall(address target) {
+ env e;
+
+ // values before
+ mathint delayBefore = getTargetAdminDelay(e, target);
+ mathint delayPendingBefore = getTargetAdminDelay_after(e, target);
+ mathint delayEffectBefore = getTargetAdminDelay_effect(e, target);
+
+ // arbitrary function call
+ method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint delayAfter = getTargetAdminDelay(e, target);
+ mathint delayPendingAfter = getTargetAdminDelay_after(e, target);
+ mathint delayEffectAfter = getTargetAdminDelay_effect(e, target);
+
+ // if anything changed ...
+ assert (
+ delayBefore != delayAfter ||
+ delayPendingBefore != delayPendingAfter ||
+ delayEffectBefore != delayEffectAfter
+ ) => (
+ (
+ // ... it was the consequence of a call to setTargetAdminDelay
+ f.selector == sig:setTargetAdminDelay(address,uint32).selector
+ ) && (
+ // ... delay cannot decrease instantly
+ delayAfter >= delayBefore
+ ) && (
+ // ... if setback is not 0, value cannot change instantly
+ minSetback() > 0 => (
+ delayBefore == delayAfter
+ )
+ ) && (
+ // ... if the value did not change and there is a minSetback, there must be something scheduled in the future
+ delayAfter == delayBefore && minSetback() > 0 => (
+ delayEffectAfter >= clock(e) + minSetback()
+ )
+ // note: if there is no minSetback, and if the caller "confirms" the current value,
+ // then this as immediate effect and nothing is scheduled
+ ) && (
+ // ... if the value changed, then no further change should be scheduled
+ delayAfter != delayBefore => (
+ delayPendingAfter == 0 &&
+ delayEffectAfter == 0
+ )
+ )
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getRoleGrantDelay โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getRoleGrantDelayChangeTime(uint64 roleId) {
+ env e1;
+ env e2;
+
+ // values before
+ mathint delayBefore = getRoleGrantDelay(e1, roleId);
+ mathint delayPendingBefore = getRoleGrantDelay_after(e1, roleId);
+ mathint delayEffectBefore = getRoleGrantDelay_effect(e1, roleId);
+
+ // time pass: e1 โ e2
+ require clock(e1) <= clock(e2);
+
+ // values after
+ mathint delayAfter = getRoleGrantDelay(e2, roleId);
+ mathint delayPendingAfter = getRoleGrantDelay_after(e2, roleId);
+ mathint delayEffectAfter = getRoleGrantDelay_effect(e2, roleId);
+
+ assert (
+ delayBefore != delayAfter ||
+ delayPendingBefore != delayPendingAfter ||
+ delayEffectBefore != delayEffectAfter
+ ) => (
+ delayEffectBefore > clock(e1) &&
+ delayEffectBefore <= clock(e2) &&
+ delayAfter == delayPendingBefore &&
+ delayPendingAfter == 0 &&
+ delayEffectAfter == 0
+ );
+}
+
+rule getRoleGrantDelayChangeCall(uint64 roleId) {
+ env e;
+
+ // values before
+ mathint delayBefore = getRoleGrantDelay(e, roleId);
+ mathint delayPendingBefore = getRoleGrantDelay_after(e, roleId);
+ mathint delayEffectBefore = getRoleGrantDelay_effect(e, roleId);
+
+ // arbitrary function call
+ method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint delayAfter = getRoleGrantDelay(e, roleId);
+ mathint delayPendingAfter = getRoleGrantDelay_after(e, roleId);
+ mathint delayEffectAfter = getRoleGrantDelay_effect(e, roleId);
+
+ // if anything changed ...
+ assert (
+ delayBefore != delayAfter ||
+ delayPendingBefore != delayPendingAfter ||
+ delayEffectBefore != delayEffectAfter
+ ) => (
+ (
+ // ... it was the consequence of a call to setTargetAdminDelay
+ f.selector == sig:setGrantDelay(uint64,uint32).selector
+ ) && (
+ // ... delay cannot decrease instantly
+ delayAfter >= delayBefore
+ ) && (
+ // ... if setback is not 0, value cannot change instantly
+ minSetback() > 0 => (
+ delayBefore == delayAfter
+ )
+ ) && (
+ // ... if the value did not change and there is a minSetback, there must be something scheduled in the future
+ delayAfter == delayBefore && minSetback() > 0 => (
+ delayEffectAfter >= clock(e) + minSetback()
+ )
+ // note: if there is no minSetback, and if the caller "confirms" the current value,
+ // then this as immediate effect and nothing is scheduled
+ ) && (
+ // ... if the value changed, then no further change should be scheduled
+ delayAfter != delayBefore => (
+ delayPendingAfter == 0 &&
+ delayEffectAfter == 0
+ )
+ )
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getRoleAdmin & getRoleGuardian โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getRoleAdminChangeCall(uint64 roleId) {
+ // values before
+ mathint adminIdBefore = getRoleAdmin(roleId);
+
+ // arbitrary function call
+ env e; method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint adminIdAfter = getRoleAdmin(roleId);
+
+ // transitions
+ assert adminIdBefore != adminIdAfter => f.selector == sig:setRoleAdmin(uint64,uint64).selector;
+}
+
+rule getRoleGuardianChangeCall(uint64 roleId) {
+ // values before
+ mathint guardianIdBefore = getRoleGuardian(roleId);
+
+ // arbitrary function call
+ env e; method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint guardianIdAfter = getRoleGuardian(roleId);
+
+ // transitions
+ assert guardianIdBefore != guardianIdAfter => (
+ f.selector == sig:setRoleGuardian(uint64,uint64).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getNonce โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getNonceChangeCall(bytes32 operationId) {
+ // values before
+ mathint nonceBefore = getNonce(operationId);
+
+ // reasonable assumption
+ require nonceBefore < max_uint32;
+
+ // arbitrary function call
+ env e; method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint nonceAfter = getNonce(operationId);
+
+ // transitions
+ assert nonceBefore != nonceAfter => (
+ f.selector == sig:schedule(address,bytes,uint48).selector &&
+ nonceAfter == nonceBefore + 1
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ State transitions: getSchedule โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getScheduleChangeTime(bytes32 operationId) {
+ env e1;
+ env e2;
+
+ // values before
+ mathint scheduleBefore = getSchedule(e1, operationId);
+
+ // time pass: e1 โ e2
+ require clock(e1) <= clock(e2);
+
+ // values after
+ mathint scheduleAfter = getSchedule(e2, operationId);
+
+ // transition
+ assert scheduleBefore != scheduleAfter => (
+ scheduleBefore + expiration() > clock(e1) &&
+ scheduleBefore + expiration() <= clock(e2) &&
+ scheduleAfter == 0
+ );
+}
+
+rule getScheduleChangeCall(bytes32 operationId) {
+ env e;
+
+ // values before
+ mathint scheduleBefore = getSchedule(e, operationId);
+
+ // arbitrary function call
+ method f; calldataarg args; f(e, args);
+
+ // values after
+ mathint scheduleAfter = getSchedule(e, operationId);
+
+ // transitions
+ assert scheduleBefore != scheduleAfter => (
+ (f.selector == sig:schedule(address,bytes,uint48).selector && scheduleAfter >= clock(e)) ||
+ (f.selector == sig:execute(address,bytes).selector && scheduleAfter == 0 ) ||
+ (f.selector == sig:cancel(address,address,bytes).selector && scheduleAfter == 0 ) ||
+ (f.selector == sig:consumeScheduledOp(address,bytes).selector && scheduleAfter == 0 ) ||
+ (isOnlyAuthorized(to_bytes4(f.selector)) && scheduleAfter == 0 )
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Functions: restricted functions can only be called by owner โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule restrictedFunctions(env e) {
+ require nonpayable(e);
+ require sanity(e);
+
+ method f;
+ calldataarg args;
+
+ f(e,args);
+
+ assert (
+ f.selector == sig:labelRole(uint64,string).selector ||
+ f.selector == sig:setRoleAdmin(uint64,uint64).selector ||
+ f.selector == sig:setRoleGuardian(uint64,uint64).selector ||
+ f.selector == sig:setGrantDelay(uint64,uint32).selector ||
+ f.selector == sig:setTargetAdminDelay(address,uint32).selector ||
+ f.selector == sig:updateAuthority(address,address).selector ||
+ f.selector == sig:setTargetClosed(address,bool).selector ||
+ f.selector == sig:setTargetFunctionRole(address,bytes4[],uint64).selector
+ ) => (
+ hasRole_isMember(e, ADMIN_ROLE(), e.msg.sender) || e.msg.sender == currentContract
+ );
+}
+
+rule restrictedFunctionsGrantRole(env e) {
+ require nonpayable(e);
+ require sanity(e);
+
+ uint64 roleId;
+ address account;
+ uint32 executionDelay;
+
+ // We want to check that the caller has the admin role before we possibly grant it.
+ bool hasAdminRoleBefore = hasRole_isMember(e, getRoleAdmin(roleId), e.msg.sender);
+
+ grantRole(e, roleId, account, executionDelay);
+
+ assert hasAdminRoleBefore || e.msg.sender == currentContract;
+}
+
+rule restrictedFunctionsRevokeRole(env e) {
+ require nonpayable(e);
+ require sanity(e);
+
+ uint64 roleId;
+ address account;
+
+ // This is needed if roleId is self-administered, the `revokeRole` call could target
+ // e.msg.sender and remove the very role that is necessary for authorizing the call.
+ bool hasAdminRoleBefore = hasRole_isMember(e, getRoleAdmin(roleId), e.msg.sender);
+
+ revokeRole(e, roleId, account);
+
+ assert hasAdminRoleBefore || e.msg.sender == currentContract;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Functions: canCall delay is enforced for calls to execute (only for others target) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+// getScheduleChangeCall proves that only {schedule} can set an operation schedule to a non 0 value
+rule callDelayEnforce_scheduleInTheFuture(env e) {
+ address target;
+ bytes data;
+ uint48 when;
+
+ // Condition: calling a third party with a delay
+ mathint delay = canCallExtended_delay(e, e.msg.sender, target, data);
+ require delay > 0;
+
+ // Schedule
+ schedule(e, target, data, when);
+
+ // Get operation schedule
+ mathint timepoint = getSchedule(e, hashOperation(e.msg.sender, target, data));
+
+ // Schedule is far enough in the future
+ assert timepoint == max(clock(e) + delay, when);
+}
+
+rule callDelayEnforce_executeAfterDelay(env e) {
+ address target;
+ bytes data;
+
+ // Condition: calling a third party with a delay
+ mathint delay = canCallExtended_delay(e, e.msg.sender, target, data);
+
+ // Get operation schedule before
+ mathint scheduleBefore = getSchedule(e, hashOperation(e.msg.sender, target, data));
+
+ // Do call
+ execute@withrevert(e, target, data);
+ bool success = !lastReverted;
+
+ // Get operation schedule after
+ mathint scheduleAfter = getSchedule(e, hashOperation(e.msg.sender, target, data));
+
+ // Can only execute if delay is set and has passed
+ assert success => (
+ delay > 0 => (
+ scheduleBefore != 0 &&
+ scheduleBefore <= clock(e)
+ ) &&
+ scheduleAfter == 0
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/DoubleEndedQueue.spec b/con/lib/openzeppelin-contracts/certora/specs/DoubleEndedQueue.spec
new file mode 100644
index 000000000..3b71bb4c7
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/DoubleEndedQueue.spec
@@ -0,0 +1,300 @@
+import "helpers/helpers.spec";
+
+methods {
+ function pushFront(bytes32) external envfree;
+ function pushBack(bytes32) external envfree;
+ function popFront() external returns (bytes32) envfree;
+ function popBack() external returns (bytes32) envfree;
+ function clear() external envfree;
+
+ // exposed for FV
+ function begin() external returns (uint128) envfree;
+ function end() external returns (uint128) envfree;
+
+ // view
+ function length() external returns (uint256) envfree;
+ function empty() external returns (bool) envfree;
+ function front() external returns (bytes32) envfree;
+ function back() external returns (bytes32) envfree;
+ function at_(uint256) external returns (bytes32) envfree; // at is a reserved word
+}
+
+definition full() returns bool = length() == max_uint128;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: empty() is length 0 and no element exists โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant emptiness()
+ empty() <=> length() == 0
+ filtered { f -> !f.isView }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: front points to the first index and back points to the last one โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant queueFront()
+ at_(0) == front()
+ filtered { f -> !f.isView }
+
+invariant queueBack()
+ at_(require_uint256(length() - 1)) == back()
+ filtered { f -> !f.isView }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: pushFront adds an element at the beginning of the queue โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pushFront(bytes32 value) {
+ uint256 lengthBefore = length();
+ bool fullBefore = full();
+
+ pushFront@withrevert(value);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> !fullBefore, "never revert if not previously full";
+
+ // effect
+ assert success => front() == value, "front set to value";
+ assert success => to_mathint(length()) == lengthBefore + 1, "queue extended";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: pushFront preserves the previous values in the queue with a +1 offset โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pushFrontConsistency(uint256 index) {
+ bytes32 beforeAt = at_(index);
+
+ bytes32 value;
+ pushFront(value);
+
+ // try to read value
+ bytes32 afterAt = at_@withrevert(require_uint256(index + 1));
+
+ assert !lastReverted, "value still there";
+ assert afterAt == beforeAt, "data is preserved";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: pushBack adds an element at the end of the queue โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pushBack(bytes32 value) {
+ uint256 lengthBefore = length();
+ bool fullBefore = full();
+
+ pushBack@withrevert(value);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> !fullBefore, "never revert if not previously full";
+
+ // effect
+ assert success => back() == value, "back set to value";
+ assert success => to_mathint(length()) == lengthBefore + 1, "queue increased";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: pushBack preserves the previous values in the queue โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pushBackConsistency(uint256 index) {
+ bytes32 beforeAt = at_(index);
+
+ bytes32 value;
+ pushBack(value);
+
+ // try to read value
+ bytes32 afterAt = at_@withrevert(index);
+
+ assert !lastReverted, "value still there";
+ assert afterAt == beforeAt, "data is preserved";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: popFront removes an element from the beginning of the queue โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule popFront {
+ uint256 lengthBefore = length();
+ bytes32 frontBefore = front@withrevert();
+
+ bytes32 popped = popFront@withrevert();
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> lengthBefore != 0, "never reverts if not previously empty";
+
+ // effect
+ assert success => frontBefore == popped, "previous front is returned";
+ assert success => to_mathint(length()) == lengthBefore - 1, "queue decreased";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: at(x) is preserved and offset to at(x - 1) after calling popFront |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule popFrontConsistency(uint256 index) {
+ // Read (any) value that is not the front (this asserts the value exists / the queue is long enough)
+ require index > 1;
+ bytes32 before = at_(index);
+
+ popFront();
+
+ // try to read value
+ bytes32 after = at_@withrevert(require_uint256(index - 1));
+
+ assert !lastReverted, "value still exists in the queue";
+ assert before == after, "values are offset and not modified";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: popBack removes an element from the end of the queue โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule popBack {
+ uint256 lengthBefore = length();
+ bytes32 backBefore = back@withrevert();
+
+ bytes32 popped = popBack@withrevert();
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> lengthBefore != 0, "never reverts if not previously empty";
+
+ // effect
+ assert success => backBefore == popped, "previous back is returned";
+ assert success => to_mathint(length()) == lengthBefore - 1, "queue decreased";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: at(x) is preserved after calling popBack |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule popBackConsistency(uint256 index) {
+ // Read (any) value that is not the back (this asserts the value exists / the queue is long enough)
+ require to_mathint(index) < length() - 1;
+ bytes32 before = at_(index);
+
+ popBack();
+
+ // try to read value
+ bytes32 after = at_@withrevert(index);
+
+ assert !lastReverted, "value still exists in the queue";
+ assert before == after, "values are offset and not modified";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: clear sets length to 0 โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule clear {
+ clear@withrevert();
+
+ // liveness
+ assert !lastReverted, "never reverts";
+
+ // effect
+ assert length() == 0, "sets length to 0";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: front/back access reverts only if the queue is empty or querying out of bounds โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyEmptyOrFullRevert(env e) {
+ require nonpayable(e);
+
+ method f;
+ calldataarg args;
+
+ bool emptyBefore = empty();
+ bool fullBefore = full();
+
+ f@withrevert(e, args);
+
+ assert lastReverted => (
+ (f.selector == sig:front().selector && emptyBefore) ||
+ (f.selector == sig:back().selector && emptyBefore) ||
+ (f.selector == sig:popFront().selector && emptyBefore) ||
+ (f.selector == sig:popBack().selector && emptyBefore) ||
+ (f.selector == sig:pushFront(bytes32).selector && fullBefore ) ||
+ (f.selector == sig:pushBack(bytes32).selector && fullBefore ) ||
+ f.selector == sig:at_(uint256).selector // revert conditions are verified in onlyOutOfBoundsRevert
+ ), "only revert if empty or out of bounds";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: at(index) only reverts if index is out of bounds |
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyOutOfBoundsRevert(uint256 index) {
+ at_@withrevert(index);
+
+ assert lastReverted <=> index >= length(), "only reverts if index is out of bounds";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: only clear/push/pop operations can change the length of the queue โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noLengthChange(env e) {
+ method f;
+ calldataarg args;
+
+ uint256 lengthBefore = length();
+ f(e, args);
+ uint256 lengthAfter = length();
+
+ assert lengthAfter != lengthBefore => (
+ (f.selector == sig:pushFront(bytes32).selector && to_mathint(lengthAfter) == lengthBefore + 1) ||
+ (f.selector == sig:pushBack(bytes32).selector && to_mathint(lengthAfter) == lengthBefore + 1) ||
+ (f.selector == sig:popBack().selector && to_mathint(lengthAfter) == lengthBefore - 1) ||
+ (f.selector == sig:popFront().selector && to_mathint(lengthAfter) == lengthBefore - 1) ||
+ (f.selector == sig:clear().selector && lengthAfter == 0)
+ ), "length is only affected by clear/pop/push operations";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: only push/pop can change values bounded in the queue (outside values aren't cleared) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noDataChange(env e) {
+ method f;
+ calldataarg args;
+
+ uint256 index;
+ bytes32 atBefore = at_(index);
+ f(e, args);
+ bytes32 atAfter = at_@withrevert(index);
+ bool atAfterSuccess = !lastReverted;
+
+ assert !atAfterSuccess <=> (
+ (f.selector == sig:clear().selector ) ||
+ (f.selector == sig:popBack().selector && index == length()) ||
+ (f.selector == sig:popFront().selector && index == length())
+ ), "indexes of the queue are only removed by clear or pop";
+
+ assert atAfterSuccess && atAfter != atBefore => (
+ f.selector == sig:popFront().selector ||
+ f.selector == sig:pushFront(bytes32).selector
+ ), "values of the queue are only changed by popFront or pushFront";
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/ERC20.spec b/con/lib/openzeppelin-contracts/certora/specs/ERC20.spec
new file mode 100644
index 000000000..21a033585
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/ERC20.spec
@@ -0,0 +1,352 @@
+import "helpers/helpers.spec";
+import "methods/IERC20.spec";
+import "methods/IERC2612.spec";
+
+methods {
+ // exposed for FV
+ function mint(address,uint256) external;
+ function burn(address,uint256) external;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Ghost & hooks: sum of all balances โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+ghost mathint sumOfBalances {
+ init_state axiom sumOfBalances == 0;
+}
+
+// Because `balance` has a uint256 type, any balance addition in CVL1 behaved as a `require_uint256()` casting,
+// leaving out the possibility of overflow. This is not the case in CVL2 where casting became more explicit.
+// A counterexample in CVL2 is having an initial state where Alice initial balance is larger than totalSupply, which
+// overflows Alice's balance when receiving a transfer. This is not possible unless the contract is deployed into an
+// already used address (or upgraded from corrupted state).
+// We restrict such behavior by making sure no balance is greater than the sum of balances.
+hook Sload uint256 balance _balances[KEY address addr] STORAGE {
+ require sumOfBalances >= to_mathint(balance);
+}
+
+hook Sstore _balances[KEY address addr] uint256 newValue (uint256 oldValue) STORAGE {
+ sumOfBalances = sumOfBalances - oldValue + newValue;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: totalSupply is the sum of all balances โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant totalSupplyIsSumOfBalances()
+ to_mathint(totalSupply()) == sumOfBalances;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: balance of address(0) is 0 โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant zeroAddressNoBalance()
+ balanceOf(0) == 0;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: only mint and burn can change total supply โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noChangeTotalSupply(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+
+ method f;
+ calldataarg args;
+
+ uint256 totalSupplyBefore = totalSupply();
+ f(e, args);
+ uint256 totalSupplyAfter = totalSupply();
+
+ assert totalSupplyAfter > totalSupplyBefore => f.selector == sig:mint(address,uint256).selector;
+ assert totalSupplyAfter < totalSupplyBefore => f.selector == sig:burn(address,uint256).selector;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: only the token holder or an approved third party can reduce an account's balance โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyAuthorizedCanTransfer(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+
+ method f;
+ calldataarg args;
+ address account;
+
+ uint256 allowanceBefore = allowance(account, e.msg.sender);
+ uint256 balanceBefore = balanceOf(account);
+ f(e, args);
+ uint256 balanceAfter = balanceOf(account);
+
+ assert (
+ balanceAfter < balanceBefore
+ ) => (
+ f.selector == sig:burn(address,uint256).selector ||
+ e.msg.sender == account ||
+ balanceBefore - balanceAfter <= to_mathint(allowanceBefore)
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: only the token holder (or a permit) can increase allowance. The spender can decrease it by using it โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyHolderOfSpenderCanChangeAllowance(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+
+ method f;
+ calldataarg args;
+ address holder;
+ address spender;
+
+ uint256 allowanceBefore = allowance(holder, spender);
+ f(e, args);
+ uint256 allowanceAfter = allowance(holder, spender);
+
+ assert (
+ allowanceAfter > allowanceBefore
+ ) => (
+ (f.selector == sig:approve(address,uint256).selector && e.msg.sender == holder) ||
+ (f.selector == sig:permit(address,address,uint256,uint256,uint8,bytes32,bytes32).selector)
+ );
+
+ assert (
+ allowanceAfter < allowanceBefore
+ ) => (
+ (f.selector == sig:transferFrom(address,address,uint256).selector && e.msg.sender == spender) ||
+ (f.selector == sig:approve(address,uint256).selector && e.msg.sender == holder ) ||
+ (f.selector == sig:permit(address,address,uint256,uint256,uint8,bytes32,bytes32).selector)
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: mint behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule mint(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+ require nonpayable(e);
+
+ address to;
+ address other;
+ uint256 amount;
+
+ // cache state
+ uint256 toBalanceBefore = balanceOf(to);
+ uint256 otherBalanceBefore = balanceOf(other);
+ uint256 totalSupplyBefore = totalSupply();
+
+ // run transaction
+ mint@withrevert(e, to, amount);
+
+ // check outcome
+ if (lastReverted) {
+ assert to == 0 || totalSupplyBefore + amount > max_uint256;
+ } else {
+ // updates balance and totalSupply
+ assert to_mathint(balanceOf(to)) == toBalanceBefore + amount;
+ assert to_mathint(totalSupply()) == totalSupplyBefore + amount;
+
+ // no other balance is modified
+ assert balanceOf(other) != otherBalanceBefore => other == to;
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: burn behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule burn(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+ require nonpayable(e);
+
+ address from;
+ address other;
+ uint256 amount;
+
+ // cache state
+ uint256 fromBalanceBefore = balanceOf(from);
+ uint256 otherBalanceBefore = balanceOf(other);
+ uint256 totalSupplyBefore = totalSupply();
+
+ // run transaction
+ burn@withrevert(e, from, amount);
+
+ // check outcome
+ if (lastReverted) {
+ assert from == 0 || fromBalanceBefore < amount;
+ } else {
+ // updates balance and totalSupply
+ assert to_mathint(balanceOf(from)) == fromBalanceBefore - amount;
+ assert to_mathint(totalSupply()) == totalSupplyBefore - amount;
+
+ // no other balance is modified
+ assert balanceOf(other) != otherBalanceBefore => other == from;
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: transfer behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule transfer(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+ require nonpayable(e);
+
+ address holder = e.msg.sender;
+ address recipient;
+ address other;
+ uint256 amount;
+
+ // cache state
+ uint256 holderBalanceBefore = balanceOf(holder);
+ uint256 recipientBalanceBefore = balanceOf(recipient);
+ uint256 otherBalanceBefore = balanceOf(other);
+
+ // run transaction
+ transfer@withrevert(e, recipient, amount);
+
+ // check outcome
+ if (lastReverted) {
+ assert holder == 0 || recipient == 0 || amount > holderBalanceBefore;
+ } else {
+ // balances of holder and recipient are updated
+ assert to_mathint(balanceOf(holder)) == holderBalanceBefore - (holder == recipient ? 0 : amount);
+ assert to_mathint(balanceOf(recipient)) == recipientBalanceBefore + (holder == recipient ? 0 : amount);
+
+ // no other balance is modified
+ assert balanceOf(other) != otherBalanceBefore => (other == holder || other == recipient);
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: transferFrom behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule transferFrom(env e) {
+ requireInvariant totalSupplyIsSumOfBalances();
+ require nonpayable(e);
+
+ address spender = e.msg.sender;
+ address holder;
+ address recipient;
+ address other;
+ uint256 amount;
+
+ // cache state
+ uint256 allowanceBefore = allowance(holder, spender);
+ uint256 holderBalanceBefore = balanceOf(holder);
+ uint256 recipientBalanceBefore = balanceOf(recipient);
+ uint256 otherBalanceBefore = balanceOf(other);
+
+ // run transaction
+ transferFrom@withrevert(e, holder, recipient, amount);
+
+ // check outcome
+ if (lastReverted) {
+ assert holder == 0 || recipient == 0 || spender == 0 || amount > holderBalanceBefore || amount > allowanceBefore;
+ } else {
+ // allowance is valid & updated
+ assert allowanceBefore >= amount;
+ assert to_mathint(allowance(holder, spender)) == (allowanceBefore == max_uint256 ? max_uint256 : allowanceBefore - amount);
+
+ // balances of holder and recipient are updated
+ assert to_mathint(balanceOf(holder)) == holderBalanceBefore - (holder == recipient ? 0 : amount);
+ assert to_mathint(balanceOf(recipient)) == recipientBalanceBefore + (holder == recipient ? 0 : amount);
+
+ // no other balance is modified
+ assert balanceOf(other) != otherBalanceBefore => (other == holder || other == recipient);
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: approve behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule approve(env e) {
+ require nonpayable(e);
+
+ address holder = e.msg.sender;
+ address spender;
+ address otherHolder;
+ address otherSpender;
+ uint256 amount;
+
+ // cache state
+ uint256 otherAllowanceBefore = allowance(otherHolder, otherSpender);
+
+ // run transaction
+ approve@withrevert(e, spender, amount);
+
+ // check outcome
+ if (lastReverted) {
+ assert holder == 0 || spender == 0;
+ } else {
+ // allowance is updated
+ assert allowance(holder, spender) == amount;
+
+ // other allowances are untouched
+ assert allowance(otherHolder, otherSpender) != otherAllowanceBefore => (otherHolder == holder && otherSpender == spender);
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: permit behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule permit(env e) {
+ require nonpayable(e);
+
+ address holder;
+ address spender;
+ uint256 amount;
+ uint256 deadline;
+ uint8 v;
+ bytes32 r;
+ bytes32 s;
+
+ address account1;
+ address account2;
+ address account3;
+
+ // cache state
+ uint256 nonceBefore = nonces(holder);
+ uint256 otherNonceBefore = nonces(account1);
+ uint256 otherAllowanceBefore = allowance(account2, account3);
+
+ // sanity: nonce overflow, which possible in theory, is assumed to be impossible in practice
+ require nonceBefore < max_uint256;
+ require otherNonceBefore < max_uint256;
+
+ // run transaction
+ permit@withrevert(e, holder, spender, amount, deadline, v, r, s);
+
+ // check outcome
+ if (lastReverted) {
+ // Without formally checking the signature, we can't verify exactly the revert causes
+ assert true;
+ } else {
+ // allowance and nonce are updated
+ assert allowance(holder, spender) == amount;
+ assert to_mathint(nonces(holder)) == nonceBefore + 1;
+
+ // deadline was respected
+ assert deadline >= e.block.timestamp;
+
+ // no other allowance or nonce is modified
+ assert nonces(account1) != otherNonceBefore => account1 == holder;
+ assert allowance(account2, account3) != otherAllowanceBefore => (account2 == holder && account3 == spender);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/ERC20FlashMint.spec b/con/lib/openzeppelin-contracts/certora/specs/ERC20FlashMint.spec
new file mode 100644
index 000000000..6942495b0
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/ERC20FlashMint.spec
@@ -0,0 +1,55 @@
+import "helpers/helpers.spec";
+import "methods/IERC20.spec";
+import "methods/IERC3156FlashLender.spec";
+import "methods/IERC3156FlashBorrower.spec";
+
+methods {
+ // non standard ERC-3156 functions
+ function flashFeeReceiver() external returns (address) envfree;
+
+ // function summaries below
+ function _._update(address from, address to, uint256 amount) internal => specUpdate(from, to, amount) expect void ALL;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Ghost: track mint and burns in the CVL โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+ghost mapping(address => mathint) trackedMintAmount;
+ghost mapping(address => mathint) trackedBurnAmount;
+ghost mapping(address => mapping(address => mathint)) trackedTransferredAmount;
+
+function specUpdate(address from, address to, uint256 amount) {
+ if (from == 0 && to == 0) { assert(false); } // defensive
+
+ if (from == 0) {
+ trackedMintAmount[to] = amount;
+ } else if (to == 0) {
+ trackedBurnAmount[from] = amount;
+ } else {
+ trackedTransferredAmount[from][to] = amount;
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: When doing a flashLoan, "amount" is minted and burnt, additionally, the fee is either burnt โ
+โ (if the fee recipient is 0) or transferred (if the fee recipient is not 0) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule checkMintAndBurn(env e) {
+ address receiver;
+ address token;
+ uint256 amount;
+ bytes data;
+
+ uint256 fees = flashFee(token, amount);
+ address recipient = flashFeeReceiver();
+
+ flashLoan(e, receiver, token, amount, data);
+
+ assert trackedMintAmount[receiver] == to_mathint(amount);
+ assert trackedBurnAmount[receiver] == amount + to_mathint(recipient == 0 ? fees : 0);
+ assert (fees > 0 && recipient != 0) => trackedTransferredAmount[receiver][recipient] == to_mathint(fees);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/ERC20Wrapper.spec b/con/lib/openzeppelin-contracts/certora/specs/ERC20Wrapper.spec
new file mode 100644
index 000000000..04e67042a
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/ERC20Wrapper.spec
@@ -0,0 +1,198 @@
+import "helpers/helpers.spec";
+import "ERC20.spec";
+
+methods {
+ function underlying() external returns(address) envfree;
+ function underlyingTotalSupply() external returns(uint256) envfree;
+ function underlyingBalanceOf(address) external returns(uint256) envfree;
+ function underlyingAllowanceToThis(address) external returns(uint256) envfree;
+
+ function depositFor(address, uint256) external returns(bool);
+ function withdrawTo(address, uint256) external returns(bool);
+ function recover(address) external returns(uint256);
+}
+
+use invariant totalSupplyIsSumOfBalances;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helper: consequence of `totalSupplyIsSumOfBalances` applied to underlying โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition underlyingBalancesLowerThanUnderlyingSupply(address a) returns bool =
+ underlyingBalanceOf(a) <= underlyingTotalSupply();
+
+definition sumOfUnderlyingBalancesLowerThanUnderlyingSupply(address a, address b) returns bool =
+ a != b => underlyingBalanceOf(a) + underlyingBalanceOf(b) <= to_mathint(underlyingTotalSupply());
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: wrapped token can't be undercollateralized (solvency of the wrapper) โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant totalSupplyIsSmallerThanUnderlyingBalance()
+ totalSupply() <= underlyingBalanceOf(currentContract) &&
+ underlyingBalanceOf(currentContract) <= underlyingTotalSupply() &&
+ underlyingTotalSupply() <= max_uint256
+ {
+ preserved {
+ requireInvariant totalSupplyIsSumOfBalances;
+ require underlyingBalancesLowerThanUnderlyingSupply(currentContract);
+ }
+ preserved depositFor(address account, uint256 amount) with (env e) {
+ require sumOfUnderlyingBalancesLowerThanUnderlyingSupply(e.msg.sender, currentContract);
+ }
+ }
+
+invariant noSelfWrap()
+ currentContract != underlying();
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: depositFor liveness and effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule depositFor(env e) {
+ require nonpayable(e);
+
+ address sender = e.msg.sender;
+ address receiver;
+ address other;
+ uint256 amount;
+
+ // sanity
+ requireInvariant noSelfWrap;
+ requireInvariant totalSupplyIsSumOfBalances;
+ requireInvariant totalSupplyIsSmallerThanUnderlyingBalance;
+ require sumOfUnderlyingBalancesLowerThanUnderlyingSupply(currentContract, sender);
+
+ uint256 balanceBefore = balanceOf(receiver);
+ uint256 supplyBefore = totalSupply();
+ uint256 senderUnderlyingBalanceBefore = underlyingBalanceOf(sender);
+ uint256 senderUnderlyingAllowanceBefore = underlyingAllowanceToThis(sender);
+ uint256 wrapperUnderlyingBalanceBefore = underlyingBalanceOf(currentContract);
+ uint256 underlyingSupplyBefore = underlyingTotalSupply();
+
+ uint256 otherBalanceBefore = balanceOf(other);
+ uint256 otherUnderlyingBalanceBefore = underlyingBalanceOf(other);
+
+ depositFor@withrevert(e, receiver, amount);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ sender != currentContract && // invalid sender
+ sender != 0 && // invalid sender
+ receiver != currentContract && // invalid receiver
+ receiver != 0 && // invalid receiver
+ amount <= senderUnderlyingBalanceBefore && // deposit doesn't exceed balance
+ amount <= senderUnderlyingAllowanceBefore // deposit doesn't exceed allowance
+ );
+
+ // effects
+ assert success => (
+ to_mathint(balanceOf(receiver)) == balanceBefore + amount &&
+ to_mathint(totalSupply()) == supplyBefore + amount &&
+ to_mathint(underlyingBalanceOf(currentContract)) == wrapperUnderlyingBalanceBefore + amount &&
+ to_mathint(underlyingBalanceOf(sender)) == senderUnderlyingBalanceBefore - amount
+ );
+
+ // no side effect
+ assert underlyingTotalSupply() == underlyingSupplyBefore;
+ assert balanceOf(other) != otherBalanceBefore => other == receiver;
+ assert underlyingBalanceOf(other) != otherUnderlyingBalanceBefore => (other == sender || other == currentContract);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: withdrawTo liveness and effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule withdrawTo(env e) {
+ require nonpayable(e);
+
+ address sender = e.msg.sender;
+ address receiver;
+ address other;
+ uint256 amount;
+
+ // sanity
+ requireInvariant noSelfWrap;
+ requireInvariant totalSupplyIsSumOfBalances;
+ requireInvariant totalSupplyIsSmallerThanUnderlyingBalance;
+ require sumOfUnderlyingBalancesLowerThanUnderlyingSupply(currentContract, receiver);
+
+ uint256 balanceBefore = balanceOf(sender);
+ uint256 supplyBefore = totalSupply();
+ uint256 receiverUnderlyingBalanceBefore = underlyingBalanceOf(receiver);
+ uint256 wrapperUnderlyingBalanceBefore = underlyingBalanceOf(currentContract);
+ uint256 underlyingSupplyBefore = underlyingTotalSupply();
+
+ uint256 otherBalanceBefore = balanceOf(other);
+ uint256 otherUnderlyingBalanceBefore = underlyingBalanceOf(other);
+
+ withdrawTo@withrevert(e, receiver, amount);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ sender != 0 && // invalid sender
+ receiver != currentContract && // invalid receiver
+ receiver != 0 && // invalid receiver
+ amount <= balanceBefore // withdraw doesn't exceed balance
+ );
+
+ // effects
+ assert success => (
+ to_mathint(balanceOf(sender)) == balanceBefore - amount &&
+ to_mathint(totalSupply()) == supplyBefore - amount &&
+ to_mathint(underlyingBalanceOf(currentContract)) == wrapperUnderlyingBalanceBefore - (currentContract != receiver ? amount : 0) &&
+ to_mathint(underlyingBalanceOf(receiver)) == receiverUnderlyingBalanceBefore + (currentContract != receiver ? amount : 0)
+ );
+
+ // no side effect
+ assert underlyingTotalSupply() == underlyingSupplyBefore;
+ assert balanceOf(other) != otherBalanceBefore => other == sender;
+ assert underlyingBalanceOf(other) != otherUnderlyingBalanceBefore => (other == receiver || other == currentContract);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: recover liveness and effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule recover(env e) {
+ require nonpayable(e);
+
+ address receiver;
+ address other;
+
+ // sanity
+ requireInvariant noSelfWrap;
+ requireInvariant totalSupplyIsSumOfBalances;
+ requireInvariant totalSupplyIsSmallerThanUnderlyingBalance;
+
+ mathint value = underlyingBalanceOf(currentContract) - totalSupply();
+ uint256 supplyBefore = totalSupply();
+ uint256 balanceBefore = balanceOf(receiver);
+
+ uint256 otherBalanceBefore = balanceOf(other);
+ uint256 otherUnderlyingBalanceBefore = underlyingBalanceOf(other);
+
+ recover@withrevert(e, receiver);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> receiver != 0;
+
+ // effect
+ assert success => (
+ to_mathint(balanceOf(receiver)) == balanceBefore + value &&
+ to_mathint(totalSupply()) == supplyBefore + value &&
+ totalSupply() == underlyingBalanceOf(currentContract)
+ );
+
+ // no side effect
+ assert underlyingBalanceOf(other) == otherUnderlyingBalanceBefore;
+ assert balanceOf(other) != otherBalanceBefore => other == receiver;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/ERC721.spec b/con/lib/openzeppelin-contracts/certora/specs/ERC721.spec
new file mode 100644
index 000000000..bad4c4737
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/ERC721.spec
@@ -0,0 +1,679 @@
+import "helpers/helpers.spec";
+import "methods/IERC721.spec";
+import "methods/IERC721Receiver.spec";
+
+methods {
+ // exposed for FV
+ function mint(address,uint256) external;
+ function safeMint(address,uint256) external;
+ function safeMint(address,uint256,bytes) external;
+ function burn(uint256) external;
+
+ function unsafeOwnerOf(uint256) external returns (address) envfree;
+ function unsafeGetApproved(uint256) external returns (address) envfree;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helpers โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+
+definition authSanity(env e) returns bool = e.msg.sender != 0;
+
+// Could be broken in theory, but not in practice
+definition balanceLimited(address account) returns bool = balanceOf(account) < max_uint256;
+
+function helperTransferWithRevert(env e, method f, address from, address to, uint256 tokenId) {
+ if (f.selector == sig:transferFrom(address,address,uint256).selector) {
+ transferFrom@withrevert(e, from, to, tokenId);
+ } else if (f.selector == sig:safeTransferFrom(address,address,uint256).selector) {
+ safeTransferFrom@withrevert(e, from, to, tokenId);
+ } else if (f.selector == sig:safeTransferFrom(address,address,uint256,bytes).selector) {
+ bytes params;
+ require params.length < 0xffff;
+ safeTransferFrom@withrevert(e, from, to, tokenId, params);
+ } else {
+ calldataarg args;
+ f@withrevert(e, args);
+ }
+}
+
+function helperMintWithRevert(env e, method f, address to, uint256 tokenId) {
+ if (f.selector == sig:mint(address,uint256).selector) {
+ mint@withrevert(e, to, tokenId);
+ } else if (f.selector == sig:safeMint(address,uint256).selector) {
+ safeMint@withrevert(e, to, tokenId);
+ } else if (f.selector == sig:safeMint(address,uint256,bytes).selector) {
+ bytes params;
+ require params.length < 0xffff;
+ safeMint@withrevert(e, to, tokenId, params);
+ } else {
+ require false;
+ }
+}
+
+function helperSoundFnCall(env e, method f) {
+ if (f.selector == sig:mint(address,uint256).selector) {
+ address to; uint256 tokenId;
+ require balanceLimited(to);
+ requireInvariant notMintedUnset(tokenId);
+ mint(e, to, tokenId);
+ } else if (f.selector == sig:safeMint(address,uint256).selector) {
+ address to; uint256 tokenId;
+ require balanceLimited(to);
+ requireInvariant notMintedUnset(tokenId);
+ safeMint(e, to, tokenId);
+ } else if (f.selector == sig:safeMint(address,uint256,bytes).selector) {
+ address to; uint256 tokenId; bytes data;
+ require data.length < 0xffff;
+ require balanceLimited(to);
+ requireInvariant notMintedUnset(tokenId);
+ safeMint(e, to, tokenId, data);
+ } else if (f.selector == sig:burn(uint256).selector) {
+ uint256 tokenId;
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant notMintedUnset(tokenId);
+ burn(e, tokenId);
+ } else if (f.selector == sig:transferFrom(address,address,uint256).selector) {
+ address from; address to; uint256 tokenId;
+ require balanceLimited(to);
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant notMintedUnset(tokenId);
+ transferFrom(e, from, to, tokenId);
+ } else if (f.selector == sig:safeTransferFrom(address,address,uint256).selector) {
+ address from; address to; uint256 tokenId;
+ require balanceLimited(to);
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant notMintedUnset(tokenId);
+ safeTransferFrom(e, from, to, tokenId);
+ } else if (f.selector == sig:safeTransferFrom(address,address,uint256,bytes).selector) {
+ address from; address to; uint256 tokenId; bytes data;
+ require data.length < 0xffff;
+ require balanceLimited(to);
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant notMintedUnset(tokenId);
+ safeTransferFrom(e, from, to, tokenId, data);
+ } else {
+ calldataarg args;
+ f(e, args);
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Ghost & hooks: ownership count โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+ghost mathint _ownedTotal {
+ init_state axiom _ownedTotal == 0;
+}
+
+ghost mapping(address => mathint) _ownedByUser {
+ init_state axiom forall address a. _ownedByUser[a] == 0;
+}
+
+hook Sstore _owners[KEY uint256 tokenId] address newOwner (address oldOwner) STORAGE {
+ _ownedByUser[newOwner] = _ownedByUser[newOwner] + to_mathint(newOwner != 0 ? 1 : 0);
+ _ownedByUser[oldOwner] = _ownedByUser[oldOwner] - to_mathint(oldOwner != 0 ? 1 : 0);
+ _ownedTotal = _ownedTotal + to_mathint(newOwner != 0 ? 1 : 0) - to_mathint(oldOwner != 0 ? 1 : 0);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Ghost & hooks: sum of all balances โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+ghost mathint _supply {
+ init_state axiom _supply == 0;
+}
+
+ghost mapping(address => mathint) _balances {
+ init_state axiom forall address a. _balances[a] == 0;
+}
+
+hook Sstore _balances[KEY address addr] uint256 newValue (uint256 oldValue) STORAGE {
+ _supply = _supply - oldValue + newValue;
+}
+
+// TODO: This used to not be necessary. We should try to remove it. In order to do so, we will probably need to add
+// many "preserved" directive that require the "balanceOfConsistency" invariant on the accounts involved.
+hook Sload uint256 value _balances[KEY address user] STORAGE {
+ require _balances[user] == to_mathint(value);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: number of owned tokens is the sum of all balances โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant ownedTotalIsSumOfBalances()
+ _ownedTotal == _supply
+ {
+ preserved mint(address to, uint256 tokenId) with (env e) {
+ require balanceLimited(to);
+ }
+ preserved safeMint(address to, uint256 tokenId) with (env e) {
+ require balanceLimited(to);
+ }
+ preserved safeMint(address to, uint256 tokenId, bytes data) with (env e) {
+ require balanceLimited(to);
+ }
+ preserved burn(uint256 tokenId) with (env e) {
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant balanceOfConsistency(ownerOf(tokenId));
+ }
+ preserved transferFrom(address from, address to, uint256 tokenId) with (env e) {
+ require balanceLimited(to);
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant balanceOfConsistency(from);
+ requireInvariant balanceOfConsistency(to);
+ }
+ preserved safeTransferFrom(address from, address to, uint256 tokenId) with (env e) {
+ require balanceLimited(to);
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant balanceOfConsistency(from);
+ requireInvariant balanceOfConsistency(to);
+ }
+ preserved safeTransferFrom(address from, address to, uint256 tokenId, bytes data) with (env e) {
+ require balanceLimited(to);
+ requireInvariant ownerHasBalance(tokenId);
+ requireInvariant balanceOfConsistency(from);
+ requireInvariant balanceOfConsistency(to);
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: balanceOf is the number of tokens owned โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant balanceOfConsistency(address user)
+ to_mathint(balanceOf(user)) == _ownedByUser[user] &&
+ to_mathint(balanceOf(user)) == _balances[user]
+ {
+ preserved {
+ require balanceLimited(user);
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: owner of a token must have some balance โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant ownerHasBalance(uint256 tokenId)
+ balanceOf(ownerOf(tokenId)) > 0
+ {
+ preserved {
+ requireInvariant balanceOfConsistency(ownerOf(tokenId));
+ require balanceLimited(ownerOf(tokenId));
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: balance of address(0) is 0 โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule zeroAddressBalanceRevert() {
+ balanceOf@withrevert(0);
+ assert lastReverted;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: address(0) has no authorized operator โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant zeroAddressHasNoApprovedOperator(address a)
+ !isApprovedForAll(0, a)
+ {
+ preserved with (env e) {
+ require nonzerosender(e);
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: tokens that do not exist are not owned and not approved โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant notMintedUnset(uint256 tokenId)
+ unsafeOwnerOf(tokenId) == 0 => unsafeGetApproved(tokenId) == 0;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: unsafeOwnerOf and unsafeGetApproved don't revert + ownerOf and getApproved revert if token does not exist โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule notMintedRevert(uint256 tokenId) {
+ requireInvariant notMintedUnset(tokenId);
+
+ address _owner = unsafeOwnerOf@withrevert(tokenId);
+ assert !lastReverted;
+
+ address _approved = unsafeGetApproved@withrevert(tokenId);
+ assert !lastReverted;
+
+ address owner = ownerOf@withrevert(tokenId);
+ assert lastReverted <=> _owner == 0;
+ assert !lastReverted => _owner == owner;
+
+ address approved = getApproved@withrevert(tokenId);
+ assert lastReverted <=> _owner == 0;
+ assert !lastReverted => _approved == approved;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: total supply can only change through mint and burn โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule supplyChange(env e) {
+ require nonzerosender(e);
+ requireInvariant zeroAddressHasNoApprovedOperator(e.msg.sender);
+
+ mathint supplyBefore = _supply;
+ method f; helperSoundFnCall(e, f);
+ mathint supplyAfter = _supply;
+
+ assert supplyAfter > supplyBefore => (
+ supplyAfter == supplyBefore + 1 &&
+ (
+ f.selector == sig:mint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256,bytes).selector
+ )
+ );
+ assert supplyAfter < supplyBefore => (
+ supplyAfter == supplyBefore - 1 &&
+ f.selector == sig:burn(uint256).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: balanceOf can only change through mint, burn or transfers. balanceOf cannot change by more than 1. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule balanceChange(env e, address account) {
+ requireInvariant balanceOfConsistency(account);
+ require balanceLimited(account);
+
+ mathint balanceBefore = balanceOf(account);
+ method f; helperSoundFnCall(e, f);
+ mathint balanceAfter = balanceOf(account);
+
+ // balance can change by at most 1
+ assert balanceBefore != balanceAfter => (
+ balanceAfter == balanceBefore - 1 ||
+ balanceAfter == balanceBefore + 1
+ );
+
+ // only selected function can change balances
+ assert balanceBefore != balanceAfter => (
+ f.selector == sig:transferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256,bytes).selector ||
+ f.selector == sig:mint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256,bytes).selector ||
+ f.selector == sig:burn(uint256).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: ownership can only change through mint, burn or transfers. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule ownershipChange(env e, uint256 tokenId) {
+ require nonzerosender(e);
+ requireInvariant zeroAddressHasNoApprovedOperator(e.msg.sender);
+
+ address ownerBefore = unsafeOwnerOf(tokenId);
+ method f; helperSoundFnCall(e, f);
+ address ownerAfter = unsafeOwnerOf(tokenId);
+
+ assert ownerBefore == 0 && ownerAfter != 0 => (
+ f.selector == sig:mint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256,bytes).selector
+ );
+
+ assert ownerBefore != 0 && ownerAfter == 0 => (
+ f.selector == sig:burn(uint256).selector
+ );
+
+ assert (ownerBefore != ownerAfter && ownerBefore != 0 && ownerAfter != 0) => (
+ f.selector == sig:transferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256,bytes).selector
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: token approval can only change through approve or transfers (implicitly). โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule approvalChange(env e, uint256 tokenId) {
+ address approvalBefore = unsafeGetApproved(tokenId);
+ method f; helperSoundFnCall(e, f);
+ address approvalAfter = unsafeGetApproved(tokenId);
+
+ // approve can set any value, other functions reset
+ assert approvalBefore != approvalAfter => (
+ f.selector == sig:approve(address,uint256).selector ||
+ (
+ (
+ f.selector == sig:transferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256,bytes).selector ||
+ f.selector == sig:burn(uint256).selector
+ ) && approvalAfter == 0
+ )
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: approval for all tokens can only change through isApprovedForAll. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule approvedForAllChange(env e, address owner, address spender) {
+ bool approvedForAllBefore = isApprovedForAll(owner, spender);
+ method f; helperSoundFnCall(e, f);
+ bool approvedForAllAfter = isApprovedForAll(owner, spender);
+
+ assert approvedForAllBefore != approvedForAllAfter => f.selector == sig:setApprovalForAll(address,bool).selector;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: transferFrom behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule transferFrom(env e, address from, address to, uint256 tokenId) {
+ require nonpayable(e);
+ require authSanity(e);
+
+ address operator = e.msg.sender;
+ uint256 otherTokenId;
+ address otherAccount;
+
+ requireInvariant ownerHasBalance(tokenId);
+ require balanceLimited(to);
+
+ uint256 balanceOfFromBefore = balanceOf(from);
+ uint256 balanceOfToBefore = balanceOf(to);
+ uint256 balanceOfOtherBefore = balanceOf(otherAccount);
+ address ownerBefore = unsafeOwnerOf(tokenId);
+ address otherOwnerBefore = unsafeOwnerOf(otherTokenId);
+ address approvalBefore = unsafeGetApproved(tokenId);
+ address otherApprovalBefore = unsafeGetApproved(otherTokenId);
+
+ transferFrom@withrevert(e, from, to, tokenId);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ from == ownerBefore &&
+ from != 0 &&
+ to != 0 &&
+ (operator == from || operator == approvalBefore || isApprovedForAll(ownerBefore, operator))
+ );
+
+ // effect
+ assert success => (
+ to_mathint(balanceOf(from)) == balanceOfFromBefore - assert_uint256(from != to ? 1 : 0) &&
+ to_mathint(balanceOf(to)) == balanceOfToBefore + assert_uint256(from != to ? 1 : 0) &&
+ unsafeOwnerOf(tokenId) == to &&
+ unsafeGetApproved(tokenId) == 0
+ );
+
+ // no side effect
+ assert balanceOf(otherAccount) != balanceOfOtherBefore => (otherAccount == from || otherAccount == to);
+ assert unsafeOwnerOf(otherTokenId) != otherOwnerBefore => otherTokenId == tokenId;
+ assert unsafeGetApproved(otherTokenId) != otherApprovalBefore => otherTokenId == tokenId;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: safeTransferFrom behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule safeTransferFrom(env e, method f, address from, address to, uint256 tokenId) filtered { f ->
+ f.selector == sig:safeTransferFrom(address,address,uint256).selector ||
+ f.selector == sig:safeTransferFrom(address,address,uint256,bytes).selector
+} {
+ require nonpayable(e);
+ require authSanity(e);
+
+ address operator = e.msg.sender;
+ uint256 otherTokenId;
+ address otherAccount;
+
+ requireInvariant ownerHasBalance(tokenId);
+ require balanceLimited(to);
+
+ uint256 balanceOfFromBefore = balanceOf(from);
+ uint256 balanceOfToBefore = balanceOf(to);
+ uint256 balanceOfOtherBefore = balanceOf(otherAccount);
+ address ownerBefore = unsafeOwnerOf(tokenId);
+ address otherOwnerBefore = unsafeOwnerOf(otherTokenId);
+ address approvalBefore = unsafeGetApproved(tokenId);
+ address otherApprovalBefore = unsafeGetApproved(otherTokenId);
+
+ helperTransferWithRevert(e, f, from, to, tokenId);
+ bool success = !lastReverted;
+
+ assert success <=> (
+ from == ownerBefore &&
+ from != 0 &&
+ to != 0 &&
+ (operator == from || operator == approvalBefore || isApprovedForAll(ownerBefore, operator))
+ );
+
+ // effect
+ assert success => (
+ to_mathint(balanceOf(from)) == balanceOfFromBefore - assert_uint256(from != to ? 1: 0) &&
+ to_mathint(balanceOf(to)) == balanceOfToBefore + assert_uint256(from != to ? 1: 0) &&
+ unsafeOwnerOf(tokenId) == to &&
+ unsafeGetApproved(tokenId) == 0
+ );
+
+ // no side effect
+ assert balanceOf(otherAccount) != balanceOfOtherBefore => (otherAccount == from || otherAccount == to);
+ assert unsafeOwnerOf(otherTokenId) != otherOwnerBefore => otherTokenId == tokenId;
+ assert unsafeGetApproved(otherTokenId) != otherApprovalBefore => otherTokenId == tokenId;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: mint behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule mint(env e, address to, uint256 tokenId) {
+ require nonpayable(e);
+ requireInvariant notMintedUnset(tokenId);
+
+ uint256 otherTokenId;
+ address otherAccount;
+
+ require balanceLimited(to);
+
+ mathint supplyBefore = _supply;
+ uint256 balanceOfToBefore = balanceOf(to);
+ uint256 balanceOfOtherBefore = balanceOf(otherAccount);
+ address ownerBefore = unsafeOwnerOf(tokenId);
+ address otherOwnerBefore = unsafeOwnerOf(otherTokenId);
+
+ mint@withrevert(e, to, tokenId);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ ownerBefore == 0 &&
+ to != 0
+ );
+
+ // effect
+ assert success => (
+ _supply == supplyBefore + 1 &&
+ to_mathint(balanceOf(to)) == balanceOfToBefore + 1 &&
+ unsafeOwnerOf(tokenId) == to
+ );
+
+ // no side effect
+ assert balanceOf(otherAccount) != balanceOfOtherBefore => otherAccount == to;
+ assert unsafeOwnerOf(otherTokenId) != otherOwnerBefore => otherTokenId == tokenId;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: safeMint behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule safeMint(env e, method f, address to, uint256 tokenId) filtered { f ->
+ f.selector == sig:safeMint(address,uint256).selector ||
+ f.selector == sig:safeMint(address,uint256,bytes).selector
+} {
+ require nonpayable(e);
+ requireInvariant notMintedUnset(tokenId);
+
+ uint256 otherTokenId;
+ address otherAccount;
+
+ require balanceLimited(to);
+
+ mathint supplyBefore = _supply;
+ uint256 balanceOfToBefore = balanceOf(to);
+ uint256 balanceOfOtherBefore = balanceOf(otherAccount);
+ address ownerBefore = unsafeOwnerOf(tokenId);
+ address otherOwnerBefore = unsafeOwnerOf(otherTokenId);
+
+ helperMintWithRevert(e, f, to, tokenId);
+ bool success = !lastReverted;
+
+ assert success <=> (
+ ownerBefore == 0 &&
+ to != 0
+ );
+
+ // effect
+ assert success => (
+ _supply == supplyBefore + 1 &&
+ to_mathint(balanceOf(to)) == balanceOfToBefore + 1 &&
+ unsafeOwnerOf(tokenId) == to
+ );
+
+ // no side effect
+ assert balanceOf(otherAccount) != balanceOfOtherBefore => otherAccount == to;
+ assert unsafeOwnerOf(otherTokenId) != otherOwnerBefore => otherTokenId == tokenId;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: burn behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule burn(env e, uint256 tokenId) {
+ require nonpayable(e);
+
+ address from = unsafeOwnerOf(tokenId);
+ uint256 otherTokenId;
+ address otherAccount;
+
+ requireInvariant ownerHasBalance(tokenId);
+
+ mathint supplyBefore = _supply;
+ uint256 balanceOfFromBefore = balanceOf(from);
+ uint256 balanceOfOtherBefore = balanceOf(otherAccount);
+ address ownerBefore = unsafeOwnerOf(tokenId);
+ address otherOwnerBefore = unsafeOwnerOf(otherTokenId);
+ address otherApprovalBefore = unsafeGetApproved(otherTokenId);
+
+ burn@withrevert(e, tokenId);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ ownerBefore != 0
+ );
+
+ // effect
+ assert success => (
+ _supply == supplyBefore - 1 &&
+ to_mathint(balanceOf(from)) == balanceOfFromBefore - 1 &&
+ unsafeOwnerOf(tokenId) == 0 &&
+ unsafeGetApproved(tokenId) == 0
+ );
+
+ // no side effect
+ assert balanceOf(otherAccount) != balanceOfOtherBefore => otherAccount == from;
+ assert unsafeOwnerOf(otherTokenId) != otherOwnerBefore => otherTokenId == tokenId;
+ assert unsafeGetApproved(otherTokenId) != otherApprovalBefore => otherTokenId == tokenId;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: approve behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule approve(env e, address spender, uint256 tokenId) {
+ require nonpayable(e);
+ require authSanity(e);
+
+ address caller = e.msg.sender;
+ address owner = unsafeOwnerOf(tokenId);
+ uint256 otherTokenId;
+
+ address otherApprovalBefore = unsafeGetApproved(otherTokenId);
+
+ approve@withrevert(e, spender, tokenId);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ owner != 0 &&
+ (owner == caller || isApprovedForAll(owner, caller))
+ );
+
+ // effect
+ assert success => unsafeGetApproved(tokenId) == spender;
+
+ // no side effect
+ assert unsafeGetApproved(otherTokenId) != otherApprovalBefore => otherTokenId == tokenId;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: setApprovalForAll behavior and side effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule setApprovalForAll(env e, address operator, bool approved) {
+ require nonpayable(e);
+
+ address owner = e.msg.sender;
+ address otherOwner;
+ address otherOperator;
+
+ bool otherIsApprovedForAllBefore = isApprovedForAll(otherOwner, otherOperator);
+
+ setApprovalForAll@withrevert(e, operator, approved);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> operator != 0;
+
+ // effect
+ assert success => isApprovedForAll(owner, operator) == approved;
+
+ // no side effect
+ assert isApprovedForAll(otherOwner, otherOperator) != otherIsApprovedForAllBefore => (
+ otherOwner == owner &&
+ otherOperator == operator
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/EnumerableMap.spec b/con/lib/openzeppelin-contracts/certora/specs/EnumerableMap.spec
new file mode 100644
index 000000000..1801d99f7
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/EnumerableMap.spec
@@ -0,0 +1,333 @@
+import "helpers/helpers.spec";
+
+methods {
+ // library
+ function set(bytes32,bytes32) external returns (bool) envfree;
+ function remove(bytes32) external returns (bool) envfree;
+ function contains(bytes32) external returns (bool) envfree;
+ function length() external returns (uint256) envfree;
+ function key_at(uint256) external returns (bytes32) envfree;
+ function value_at(uint256) external returns (bytes32) envfree;
+ function tryGet_contains(bytes32) external returns (bool) envfree;
+ function tryGet_value(bytes32) external returns (bytes32) envfree;
+ function get(bytes32) external returns (bytes32) envfree;
+
+ // FV
+ function _positionOf(bytes32) external returns (uint256) envfree;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helpers โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition sanity() returns bool =
+ length() < max_uint256;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: the value mapping is empty for keys that are not in the EnumerableMap. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant noValueIfNotContained(bytes32 key)
+ !contains(key) => tryGet_value(key) == to_bytes32(0)
+ {
+ preserved set(bytes32 otherKey, bytes32 someValue) {
+ require sanity();
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: All indexed keys are contained โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant indexedContained(uint256 index)
+ index < length() => contains(key_at(index))
+ {
+ preserved {
+ requireInvariant consistencyIndex(index);
+ requireInvariant consistencyIndex(require_uint256(length() - 1));
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: A value can only be stored at a single location โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant atUniqueness(uint256 index1, uint256 index2)
+ index1 == index2 <=> key_at(index1) == key_at(index2)
+ {
+ preserved remove(bytes32 key) {
+ requireInvariant atUniqueness(index1, require_uint256(length() - 1));
+ requireInvariant atUniqueness(index2, require_uint256(length() - 1));
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: index <> value relationship is consistent โ
+โ โ
+โ Note that the two consistencyXxx invariants, put together, prove that at_ and _positionOf are inverse of one โ
+โ another. This proves that we have a bijection between indices (the enumerability part) and keys (the entries that โ
+โ are set and removed from the EnumerableMap). โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant consistencyIndex(uint256 index)
+ index < length() => to_mathint(_positionOf(key_at(index))) == index + 1
+ {
+ preserved remove(bytes32 key) {
+ requireInvariant consistencyIndex(require_uint256(length() - 1));
+ }
+ }
+
+invariant consistencyKey(bytes32 key)
+ contains(key) => (
+ _positionOf(key) > 0 &&
+ _positionOf(key) <= length() &&
+ key_at(require_uint256(_positionOf(key) - 1)) == key
+ )
+ {
+ preserved remove(bytes32 otherKey) {
+ requireInvariant consistencyKey(otherKey);
+ requireInvariant atUniqueness(
+ require_uint256(_positionOf(key) - 1),
+ require_uint256(_positionOf(otherKey) - 1)
+ );
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: state only changes by setting or removing elements โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule stateChange(env e, bytes32 key) {
+ require sanity();
+ requireInvariant consistencyKey(key);
+
+ uint256 lengthBefore = length();
+ bool containsBefore = contains(key);
+ bytes32 valueBefore = tryGet_value(key);
+
+ method f;
+ calldataarg args;
+ f(e, args);
+
+ uint256 lengthAfter = length();
+ bool containsAfter = contains(key);
+ bytes32 valueAfter = tryGet_value(key);
+
+ assert lengthBefore != lengthAfter => (
+ (f.selector == sig:set(bytes32,bytes32).selector && to_mathint(lengthAfter) == lengthBefore + 1) ||
+ (f.selector == sig:remove(bytes32).selector && to_mathint(lengthAfter) == lengthBefore - 1)
+ );
+
+ assert containsBefore != containsAfter => (
+ (f.selector == sig:set(bytes32,bytes32).selector && containsAfter) ||
+ (f.selector == sig:remove(bytes32).selector && !containsAfter)
+ );
+
+ assert valueBefore != valueAfter => (
+ (f.selector == sig:set(bytes32,bytes32).selector && containsAfter) ||
+ (f.selector == sig:remove(bytes32).selector && !containsAfter && valueAfter == to_bytes32(0))
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: check liveness of view functions. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule liveness_1(bytes32 key) {
+ requireInvariant consistencyKey(key);
+
+ // contains never revert
+ bool contains = contains@withrevert(key);
+ assert !lastReverted;
+
+ // tryGet never reverts (key)
+ tryGet_contains@withrevert(key);
+ assert !lastReverted;
+
+ // tryGet never reverts (value)
+ tryGet_value@withrevert(key);
+ assert !lastReverted;
+
+ // get reverts iff the key is not in the map
+ get@withrevert(key);
+ assert !lastReverted <=> contains;
+}
+
+rule liveness_2(uint256 index) {
+ requireInvariant consistencyIndex(index);
+
+ // length never revert
+ uint256 length = length@withrevert();
+ assert !lastReverted;
+
+ // key_at reverts iff the index is out of bound
+ key_at@withrevert(index);
+ assert !lastReverted <=> index < length;
+
+ // value_at reverts iff the index is out of bound
+ value_at@withrevert(index);
+ assert !lastReverted <=> index < length;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: get and tryGet return the expected values. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule getAndTryGet(bytes32 key) {
+ requireInvariant noValueIfNotContained(key);
+
+ bool contained = contains(key);
+ bool tryContained = tryGet_contains(key);
+ bytes32 tryValue = tryGet_value(key);
+ bytes32 value = get@withrevert(key); // revert is not contained
+
+ assert contained == tryContained;
+ assert contained => tryValue == value;
+ assert !contained => tryValue == to_bytes32(0);
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: set key-value in EnumerableMap โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule set(bytes32 key, bytes32 value, bytes32 otherKey) {
+ require sanity();
+
+ uint256 lengthBefore = length();
+ bool containsBefore = contains(key);
+ bool containsOtherBefore = contains(otherKey);
+ bytes32 otherValueBefore = tryGet_value(otherKey);
+
+ bool added = set@withrevert(key, value);
+ bool success = !lastReverted;
+
+ assert success && contains(key) && get(key) == value,
+ "liveness & immediate effect";
+
+ assert added <=> !containsBefore,
+ "return value: added iff not contained";
+
+ assert to_mathint(length()) == lengthBefore + to_mathint(added ? 1 : 0),
+ "effect: length increases iff added";
+
+ assert added => (key_at(lengthBefore) == key && value_at(lengthBefore) == value),
+ "effect: add at the end";
+
+ assert containsOtherBefore != contains(otherKey) => (added && key == otherKey),
+ "side effect: other keys are not affected";
+
+ assert otherValueBefore != tryGet_value(otherKey) => key == otherKey,
+ "side effect: values attached to other keys are not affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: remove key from EnumerableMap โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule remove(bytes32 key, bytes32 otherKey) {
+ requireInvariant consistencyKey(key);
+ requireInvariant consistencyKey(otherKey);
+
+ uint256 lengthBefore = length();
+ bool containsBefore = contains(key);
+ bool containsOtherBefore = contains(otherKey);
+ bytes32 otherValueBefore = tryGet_value(otherKey);
+
+ bool removed = remove@withrevert(key);
+ bool success = !lastReverted;
+
+ assert success && !contains(key),
+ "liveness & immediate effect";
+
+ assert removed <=> containsBefore,
+ "return value: removed iff contained";
+
+ assert to_mathint(length()) == lengthBefore - to_mathint(removed ? 1 : 0),
+ "effect: length decreases iff removed";
+
+ assert containsOtherBefore != contains(otherKey) => (removed && key == otherKey),
+ "side effect: other keys are not affected";
+
+ assert otherValueBefore != tryGet_value(otherKey) => key == otherKey,
+ "side effect: values attached to other keys are not affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: when adding a new key, the other keys remain in set, at the same index. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule setEnumerability(bytes32 key, bytes32 value, uint256 index) {
+ require sanity();
+
+ bytes32 atKeyBefore = key_at(index);
+ bytes32 atValueBefore = value_at(index);
+
+ set(key, value);
+
+ bytes32 atKeyAfter = key_at@withrevert(index);
+ assert !lastReverted;
+
+ bytes32 atValueAfter = value_at@withrevert(index);
+ assert !lastReverted;
+
+ assert atKeyAfter == atKeyBefore;
+ assert atValueAfter != atValueBefore => (
+ key == atKeyBefore &&
+ value == atValueAfter
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: when removing a existing key, the other keys remain in set, at the same index (except for the last one). โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule removeEnumerability(bytes32 key, uint256 index) {
+ uint256 last = require_uint256(length() - 1);
+
+ requireInvariant consistencyKey(key);
+ requireInvariant consistencyIndex(index);
+ requireInvariant consistencyIndex(last);
+
+ bytes32 atKeyBefore = key_at(index);
+ bytes32 atValueBefore = value_at(index);
+ bytes32 lastKeyBefore = key_at(last);
+ bytes32 lastValueBefore = value_at(last);
+
+ remove(key);
+
+ // can't read last value & keys (length decreased)
+ bytes32 atKeyAfter = key_at@withrevert(index);
+ assert lastReverted <=> index == last;
+
+ bytes32 atValueAfter = value_at@withrevert(index);
+ assert lastReverted <=> index == last;
+
+ // One value that is allowed to change is if previous value was removed,
+ // in that case the last value before took its place.
+ assert (
+ index != last &&
+ atKeyBefore != atKeyAfter
+ ) => (
+ atKeyBefore == key &&
+ atKeyAfter == lastKeyBefore
+ );
+
+ assert (
+ index != last &&
+ atValueBefore != atValueAfter
+ ) => (
+ atValueAfter == lastValueBefore
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/EnumerableSet.spec b/con/lib/openzeppelin-contracts/certora/specs/EnumerableSet.spec
new file mode 100644
index 000000000..94d0a918c
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/EnumerableSet.spec
@@ -0,0 +1,246 @@
+import "helpers/helpers.spec";
+
+methods {
+ // library
+ function add(bytes32) external returns (bool) envfree;
+ function remove(bytes32) external returns (bool) envfree;
+ function contains(bytes32) external returns (bool) envfree;
+ function length() external returns (uint256) envfree;
+ function at_(uint256) external returns (bytes32) envfree;
+
+ // FV
+ function _positionOf(bytes32) external returns (uint256) envfree;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helpers โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition sanity() returns bool =
+ length() < max_uint256;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: All indexed keys are contained โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant indexedContained(uint256 index)
+ index < length() => contains(at_(index))
+ {
+ preserved {
+ requireInvariant consistencyIndex(index);
+ requireInvariant consistencyIndex(require_uint256(length() - 1));
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: A value can only be stored at a single location โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant atUniqueness(uint256 index1, uint256 index2)
+ index1 == index2 <=> at_(index1) == at_(index2)
+ {
+ preserved remove(bytes32 key) {
+ requireInvariant atUniqueness(index1, require_uint256(length() - 1));
+ requireInvariant atUniqueness(index2, require_uint256(length() - 1));
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: index <> key relationship is consistent โ
+โ โ
+โ Note that the two consistencyXxx invariants, put together, prove that at_ and _positionOf are inverse of one โ
+โ another. This proves that we have a bijection between indices (the enumerability part) and keys (the entries that โ
+โ are added and removed from the EnumerableSet). โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant consistencyIndex(uint256 index)
+ index < length() => _positionOf(at_(index)) == require_uint256(index + 1)
+ {
+ preserved remove(bytes32 key) {
+ requireInvariant consistencyIndex(require_uint256(length() - 1));
+ }
+ }
+
+invariant consistencyKey(bytes32 key)
+ contains(key) => (
+ _positionOf(key) > 0 &&
+ _positionOf(key) <= length() &&
+ at_(require_uint256(_positionOf(key) - 1)) == key
+ )
+ {
+ preserved remove(bytes32 otherKey) {
+ requireInvariant consistencyKey(otherKey);
+ requireInvariant atUniqueness(
+ require_uint256(_positionOf(key) - 1),
+ require_uint256(_positionOf(otherKey) - 1)
+ );
+ }
+ }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: state only changes by adding or removing elements โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule stateChange(env e, bytes32 key) {
+ require sanity();
+ requireInvariant consistencyKey(key);
+
+ uint256 lengthBefore = length();
+ bool containsBefore = contains(key);
+
+ method f;
+ calldataarg args;
+ f(e, args);
+
+ uint256 lengthAfter = length();
+ bool containsAfter = contains(key);
+
+ assert lengthBefore != lengthAfter => (
+ (f.selector == sig:add(bytes32).selector && lengthAfter == require_uint256(lengthBefore + 1)) ||
+ (f.selector == sig:remove(bytes32).selector && lengthAfter == require_uint256(lengthBefore - 1))
+ );
+
+ assert containsBefore != containsAfter => (
+ (f.selector == sig:add(bytes32).selector && containsAfter) ||
+ (f.selector == sig:remove(bytes32).selector && containsBefore)
+ );
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: check liveness of view functions. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule liveness_1(bytes32 key) {
+ requireInvariant consistencyKey(key);
+
+ // contains never revert
+ contains@withrevert(key);
+ assert !lastReverted;
+}
+
+rule liveness_2(uint256 index) {
+ requireInvariant consistencyIndex(index);
+
+ // length never revert
+ uint256 length = length@withrevert();
+ assert !lastReverted;
+
+ // at reverts iff the index is out of bound
+ at_@withrevert(index);
+ assert !lastReverted <=> index < length;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: add key to EnumerableSet if not already contained โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule add(bytes32 key, bytes32 otherKey) {
+ require sanity();
+
+ uint256 lengthBefore = length();
+ bool containsBefore = contains(key);
+ bool containsOtherBefore = contains(otherKey);
+
+ bool added = add@withrevert(key);
+ bool success = !lastReverted;
+
+ assert success && contains(key),
+ "liveness & immediate effect";
+
+ assert added <=> !containsBefore,
+ "return value: added iff not contained";
+
+ assert length() == require_uint256(lengthBefore + to_mathint(added ? 1 : 0)),
+ "effect: length increases iff added";
+
+ assert added => at_(lengthBefore) == key,
+ "effect: add at the end";
+
+ assert containsOtherBefore != contains(otherKey) => (added && key == otherKey),
+ "side effect: other keys are not affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: remove key from EnumerableSet if already contained โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule remove(bytes32 key, bytes32 otherKey) {
+ requireInvariant consistencyKey(key);
+ requireInvariant consistencyKey(otherKey);
+
+ uint256 lengthBefore = length();
+ bool containsBefore = contains(key);
+ bool containsOtherBefore = contains(otherKey);
+
+ bool removed = remove@withrevert(key);
+ bool success = !lastReverted;
+
+ assert success && !contains(key),
+ "liveness & immediate effect";
+
+ assert removed <=> containsBefore,
+ "return value: removed iff contained";
+
+ assert length() == require_uint256(lengthBefore - to_mathint(removed ? 1 : 0)),
+ "effect: length decreases iff removed";
+
+ assert containsOtherBefore != contains(otherKey) => (removed && key == otherKey),
+ "side effect: other keys are not affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: when adding a new key, the other keys remain in set, at the same index. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule addEnumerability(bytes32 key, uint256 index) {
+ require sanity();
+
+ bytes32 atBefore = at_(index);
+ add(key);
+ bytes32 atAfter = at_@withrevert(index);
+ bool atAfterSuccess = !lastReverted;
+
+ assert atAfterSuccess;
+ assert atBefore == atAfter;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: when removing a existing key, the other keys remain in set, at the same index (except for the last one). โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule removeEnumerability(bytes32 key, uint256 index) {
+ uint256 last = require_uint256(length() - 1);
+
+ requireInvariant consistencyKey(key);
+ requireInvariant consistencyIndex(index);
+ requireInvariant consistencyIndex(last);
+
+ bytes32 atBefore = at_(index);
+ bytes32 lastBefore = at_(last);
+
+ remove(key);
+
+ // can't read last value (length decreased)
+ bytes32 atAfter = at_@withrevert(index);
+ assert lastReverted <=> index == last;
+
+ // One value that is allowed to change is if previous value was removed,
+ // in that case the last value before took its place.
+ assert (
+ index != last &&
+ atBefore != atAfter
+ ) => (
+ atBefore == key &&
+ atAfter == lastBefore
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/Initializable.spec b/con/lib/openzeppelin-contracts/certora/specs/Initializable.spec
new file mode 100644
index 000000000..07c2930c2
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/Initializable.spec
@@ -0,0 +1,165 @@
+import "helpers/helpers.spec";
+
+methods {
+ // initialize, reinitialize, disable
+ function initialize() external envfree;
+ function reinitialize(uint64) external envfree;
+ function disable() external envfree;
+
+ function nested_init_init() external envfree;
+ function nested_init_reinit(uint64) external envfree;
+ function nested_reinit_init(uint64) external envfree;
+ function nested_reinit_reinit(uint64,uint64) external envfree;
+
+ // view
+ function version() external returns uint64 envfree;
+ function initializing() external returns bool envfree;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Definitions โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition isUninitialized() returns bool = version() == 0;
+definition isInitialized() returns bool = version() > 0;
+definition isDisabled() returns bool = version() == max_uint64;
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: A contract must only ever be in an initializing state while in the middle of a transaction execution. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant notInitializing()
+ !initializing();
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: The version cannot decrease & disable state is irrevocable. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule increasingVersion(env e) {
+ uint64 versionBefore = version();
+ bool disabledBefore = isDisabled();
+
+ method f; calldataarg args;
+ f(e, args);
+
+ assert versionBefore <= version(), "_initialized must only increase";
+ assert disabledBefore => isDisabled(), "a disabled initializer must stay disabled";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Cannot initialize a contract that is already initialized. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule cannotInitializeTwice() {
+ require isInitialized();
+
+ initialize@withrevert();
+
+ assert lastReverted, "contract must only be initialized once";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Cannot initialize once disabled. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule cannotInitializeOnceDisabled() {
+ require isDisabled();
+
+ initialize@withrevert();
+
+ assert lastReverted, "contract is disabled";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Cannot reinitialize once disabled. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule cannotReinitializeOnceDisabled() {
+ require isDisabled();
+
+ uint64 n;
+ reinitialize@withrevert(n);
+
+ assert lastReverted, "contract is disabled";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Cannot nest initializers (after construction). โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule cannotNestInitializers_init_init() {
+ nested_init_init@withrevert();
+ assert lastReverted, "nested initializers";
+}
+
+rule cannotNestInitializers_init_reinit(uint64 m) {
+ nested_init_reinit@withrevert(m);
+ assert lastReverted, "nested initializers";
+}
+
+rule cannotNestInitializers_reinit_init(uint64 n) {
+ nested_reinit_init@withrevert(n);
+ assert lastReverted, "nested initializers";
+}
+
+rule cannotNestInitializers_reinit_reinit(uint64 n, uint64 m) {
+ nested_reinit_reinit@withrevert(n, m);
+ assert lastReverted, "nested initializers";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Initialize correctly sets the version. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule initializeEffects() {
+ requireInvariant notInitializing();
+
+ bool isUninitializedBefore = isUninitialized();
+
+ initialize@withrevert();
+ bool success = !lastReverted;
+
+ assert success <=> isUninitializedBefore, "can only initialize uninitialized contracts";
+ assert success => version() == 1, "initialize must set version() to 1";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Reinitialize correctly sets the version. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule reinitializeEffects() {
+ requireInvariant notInitializing();
+
+ uint64 versionBefore = version();
+
+ uint64 n;
+ reinitialize@withrevert(n);
+ bool success = !lastReverted;
+
+ assert success <=> versionBefore < n, "can only reinitialize to a latter versions";
+ assert success => version() == n, "reinitialize must set version() to n";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: Can disable. โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule disableEffect() {
+ requireInvariant notInitializing();
+
+ disable@withrevert();
+ bool success = !lastReverted;
+
+ assert success, "call to _disableInitializers failed";
+ assert isDisabled(), "disable state not set";
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/Nonces.spec b/con/lib/openzeppelin-contracts/certora/specs/Nonces.spec
new file mode 100644
index 000000000..4647c5c89
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/Nonces.spec
@@ -0,0 +1,92 @@
+import "helpers/helpers.spec";
+
+methods {
+ function nonces(address) external returns (uint256) envfree;
+ function useNonce(address) external returns (uint256) envfree;
+ function useCheckedNonce(address,uint256) external envfree;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helpers โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+function nonceSanity(address account) returns bool {
+ return nonces(account) < max_uint256;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: useNonce uses nonce โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule useNonce(address account) {
+ require nonceSanity(account);
+
+ address other;
+
+ mathint nonceBefore = nonces(account);
+ mathint otherNonceBefore = nonces(other);
+
+ mathint nonceUsed = useNonce@withrevert(account);
+ bool success = !lastReverted;
+
+ mathint nonceAfter = nonces(account);
+ mathint otherNonceAfter = nonces(other);
+
+ // liveness
+ assert success, "doesn't revert";
+
+ // effect
+ assert nonceAfter == nonceBefore + 1 && nonceBefore == nonceUsed, "nonce is used";
+
+ // no side effect
+ assert otherNonceBefore != otherNonceAfter => other == account, "no other nonce is used";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: useCheckedNonce uses only the current nonce โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule useCheckedNonce(address account, uint256 currentNonce) {
+ require nonceSanity(account);
+
+ address other;
+
+ mathint nonceBefore = nonces(account);
+ mathint otherNonceBefore = nonces(other);
+
+ useCheckedNonce@withrevert(account, currentNonce);
+ bool success = !lastReverted;
+
+ mathint nonceAfter = nonces(account);
+ mathint otherNonceAfter = nonces(other);
+
+ // liveness
+ assert success <=> to_mathint(currentNonce) == nonceBefore, "works iff current nonce is correct";
+
+ // effect
+ assert success => nonceAfter == nonceBefore + 1, "nonce is used";
+
+ // no side effect
+ assert otherNonceBefore != otherNonceAfter => other == account, "no other nonce is used";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: nonce only increments โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule nonceOnlyIncrements(address account) {
+ require nonceSanity(account);
+
+ mathint nonceBefore = nonces(account);
+
+ env e; method f; calldataarg args;
+ f(e, args);
+
+ mathint nonceAfter = nonces(account);
+
+ assert nonceAfter == nonceBefore || nonceAfter == nonceBefore + 1, "nonce only increments";
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/Ownable.spec b/con/lib/openzeppelin-contracts/certora/specs/Ownable.spec
new file mode 100644
index 000000000..0d50813cf
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/Ownable.spec
@@ -0,0 +1,77 @@
+import "helpers/helpers.spec";
+import "methods/IOwnable.spec";
+
+methods {
+ function restricted() external;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: transferOwnership changes ownership โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule transferOwnership(env e) {
+ require nonpayable(e);
+
+ address newOwner;
+ address current = owner();
+
+ transferOwnership@withrevert(e, newOwner);
+ bool success = !lastReverted;
+
+ assert success <=> (e.msg.sender == current && newOwner != 0), "unauthorized caller or invalid arg";
+ assert success => owner() == newOwner, "current owner changed";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: renounceOwnership removes the owner โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule renounceOwnership(env e) {
+ require nonpayable(e);
+
+ address current = owner();
+
+ renounceOwnership@withrevert(e);
+ bool success = !lastReverted;
+
+ assert success <=> e.msg.sender == current, "unauthorized caller";
+ assert success => owner() == 0, "owner not cleared";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Access control: only current owner can call restricted functions โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyCurrentOwnerCanCallOnlyOwner(env e) {
+ require nonpayable(e);
+
+ address current = owner();
+
+ calldataarg args;
+ restricted@withrevert(e, args);
+
+ assert !lastReverted <=> e.msg.sender == current, "access control failed";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: ownership can only change in specific ways โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyOwnerOrPendingOwnerCanChangeOwnership(env e) {
+ address oldCurrent = owner();
+
+ method f; calldataarg args;
+ f(e, args);
+
+ address newCurrent = owner();
+
+ // If owner changes, must be either transferOwnership or renounceOwnership
+ assert oldCurrent != newCurrent => (
+ (e.msg.sender == oldCurrent && newCurrent != 0 && f.selector == sig:transferOwnership(address).selector) ||
+ (e.msg.sender == oldCurrent && newCurrent == 0 && f.selector == sig:renounceOwnership().selector)
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/Ownable2Step.spec b/con/lib/openzeppelin-contracts/certora/specs/Ownable2Step.spec
new file mode 100644
index 000000000..d13c6d3e6
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/Ownable2Step.spec
@@ -0,0 +1,108 @@
+import "helpers/helpers.spec";
+import "methods/IOwnable2Step.spec";
+
+methods {
+ function restricted() external;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: transferOwnership sets the pending owner โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule transferOwnership(env e) {
+ require nonpayable(e);
+
+ address newOwner;
+ address current = owner();
+
+ transferOwnership@withrevert(e, newOwner);
+ bool success = !lastReverted;
+
+ assert success <=> e.msg.sender == current, "unauthorized caller";
+ assert success => pendingOwner() == newOwner, "pending owner not set";
+ assert success => owner() == current, "current owner changed";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: renounceOwnership removes the owner and the pendingOwner โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule renounceOwnership(env e) {
+ require nonpayable(e);
+
+ address current = owner();
+
+ renounceOwnership@withrevert(e);
+ bool success = !lastReverted;
+
+ assert success <=> e.msg.sender == current, "unauthorized caller";
+ assert success => pendingOwner() == 0, "pending owner not cleared";
+ assert success => owner() == 0, "owner not cleared";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: acceptOwnership changes owner and reset pending owner โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule acceptOwnership(env e) {
+
+ require nonpayable(e);
+
+ address current = owner();
+ address pending = pendingOwner();
+
+ acceptOwnership@withrevert(e);
+ bool success = !lastReverted;
+
+ assert success <=> e.msg.sender == pending, "unauthorized caller";
+ assert success => pendingOwner() == 0, "pending owner not cleared";
+ assert success => owner() == pending, "owner not transferred";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Access control: only current owner can call restricted functions โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule onlyCurrentOwnerCanCallOnlyOwner(env e) {
+ require nonpayable(e);
+
+ address current = owner();
+
+ calldataarg args;
+ restricted@withrevert(e, args);
+
+ assert !lastReverted <=> e.msg.sender == current, "access control failed";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: ownership and pending ownership can only change in specific ways โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule ownerOrPendingOwnerChange(env e, method f) {
+ address oldCurrent = owner();
+ address oldPending = pendingOwner();
+
+ calldataarg args;
+ f(e, args);
+
+ address newCurrent = owner();
+ address newPending = pendingOwner();
+
+ // If owner changes, must be either acceptOwnership or renounceOwnership
+ assert oldCurrent != newCurrent => (
+ (e.msg.sender == oldPending && newCurrent == oldPending && newPending == 0 && f.selector == sig:acceptOwnership().selector) ||
+ (e.msg.sender == oldCurrent && newCurrent == 0 && newPending == 0 && f.selector == sig:renounceOwnership().selector)
+ );
+
+ // If pending changes, must be either acceptance or reset
+ assert oldPending != newPending => (
+ (e.msg.sender == oldCurrent && newCurrent == oldCurrent && f.selector == sig:transferOwnership(address).selector) ||
+ (e.msg.sender == oldPending && newCurrent == oldPending && newPending == 0 && f.selector == sig:acceptOwnership().selector) ||
+ (e.msg.sender == oldCurrent && newCurrent == 0 && newPending == 0 && f.selector == sig:renounceOwnership().selector)
+ );
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/Pausable.spec b/con/lib/openzeppelin-contracts/certora/specs/Pausable.spec
new file mode 100644
index 000000000..a7aff9cc1
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/Pausable.spec
@@ -0,0 +1,96 @@
+import "helpers/helpers.spec";
+
+methods {
+ function paused() external returns (bool) envfree;
+ function pause() external;
+ function unpause() external;
+ function onlyWhenPaused() external;
+ function onlyWhenNotPaused() external;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: _pause pauses the contract โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule pause(env e) {
+ require nonpayable(e);
+
+ bool pausedBefore = paused();
+
+ pause@withrevert(e);
+ bool success = !lastReverted;
+
+ bool pausedAfter = paused();
+
+ // liveness
+ assert success <=> !pausedBefore, "works if and only if the contract was not paused before";
+
+ // effect
+ assert success => pausedAfter, "contract must be paused after a successful call";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: _unpause unpauses the contract โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule unpause(env e) {
+ require nonpayable(e);
+
+ bool pausedBefore = paused();
+
+ unpause@withrevert(e);
+ bool success = !lastReverted;
+
+ bool pausedAfter = paused();
+
+ // liveness
+ assert success <=> pausedBefore, "works if and only if the contract was paused before";
+
+ // effect
+ assert success => !pausedAfter, "contract must be unpaused after a successful call";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: whenPaused modifier can only be called if the contract is paused โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule whenPaused(env e) {
+ require nonpayable(e);
+
+ onlyWhenPaused@withrevert(e);
+ assert !lastReverted <=> paused(), "works if and only if the contract is paused";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Function correctness: whenNotPaused modifier can only be called if the contract is not paused โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule whenNotPaused(env e) {
+ require nonpayable(e);
+
+ onlyWhenNotPaused@withrevert(e);
+ assert !lastReverted <=> !paused(), "works if and only if the contract is not paused";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rules: only _pause and _unpause can change paused status โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule noPauseChange(env e) {
+ method f;
+ calldataarg args;
+
+ bool pausedBefore = paused();
+ f(e, args);
+ bool pausedAfter = paused();
+
+ assert pausedBefore != pausedAfter => (
+ (!pausedAfter && f.selector == sig:unpause().selector) ||
+ (pausedAfter && f.selector == sig:pause().selector)
+ ), "contract's paused status can only be changed by _pause() or _unpause()";
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/TimelockController.spec b/con/lib/openzeppelin-contracts/certora/specs/TimelockController.spec
new file mode 100644
index 000000000..5123768da
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/TimelockController.spec
@@ -0,0 +1,274 @@
+import "helpers/helpers.spec";
+import "methods/IAccessControl.spec";
+
+methods {
+ function PROPOSER_ROLE() external returns (bytes32) envfree;
+ function EXECUTOR_ROLE() external returns (bytes32) envfree;
+ function CANCELLER_ROLE() external returns (bytes32) envfree;
+ function isOperation(bytes32) external returns (bool);
+ function isOperationPending(bytes32) external returns (bool);
+ function isOperationReady(bytes32) external returns (bool);
+ function isOperationDone(bytes32) external returns (bool);
+ function getTimestamp(bytes32) external returns (uint256) envfree;
+ function getMinDelay() external returns (uint256) envfree;
+
+ function hashOperation(address, uint256, bytes, bytes32, bytes32) external returns(bytes32) envfree;
+ function hashOperationBatch(address[], uint256[], bytes[], bytes32, bytes32) external returns(bytes32) envfree;
+
+ function schedule(address, uint256, bytes, bytes32, bytes32, uint256) external;
+ function scheduleBatch(address[], uint256[], bytes[], bytes32, bytes32, uint256) external;
+ function execute(address, uint256, bytes, bytes32, bytes32) external;
+ function executeBatch(address[], uint256[], bytes[], bytes32, bytes32) external;
+ function cancel(bytes32) external;
+
+ function updateDelay(uint256) external;
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Helpers โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+// Uniformly handle scheduling of batched and non-batched operations.
+function helperScheduleWithRevert(env e, method f, bytes32 id, uint256 delay) {
+ if (f.selector == sig:schedule(address, uint256, bytes, bytes32, bytes32, uint256).selector) {
+ address target; uint256 value; bytes data; bytes32 predecessor; bytes32 salt;
+ require hashOperation(target, value, data, predecessor, salt) == id; // Correlation
+ schedule@withrevert(e, target, value, data, predecessor, salt, delay);
+ } else if (f.selector == sig:scheduleBatch(address[], uint256[], bytes[], bytes32, bytes32, uint256).selector) {
+ address[] targets; uint256[] values; bytes[] payloads; bytes32 predecessor; bytes32 salt;
+ require hashOperationBatch(targets, values, payloads, predecessor, salt) == id; // Correlation
+ scheduleBatch@withrevert(e, targets, values, payloads, predecessor, salt, delay);
+ } else {
+ calldataarg args;
+ f@withrevert(e, args);
+ }
+}
+
+// Uniformly handle execution of batched and non-batched operations.
+function helperExecuteWithRevert(env e, method f, bytes32 id, bytes32 predecessor) {
+ if (f.selector == sig:execute(address, uint256, bytes, bytes32, bytes32).selector) {
+ address target; uint256 value; bytes data; bytes32 salt;
+ require hashOperation(target, value, data, predecessor, salt) == id; // Correlation
+ execute@withrevert(e, target, value, data, predecessor, salt);
+ } else if (f.selector == sig:executeBatch(address[], uint256[], bytes[], bytes32, bytes32).selector) {
+ address[] targets; uint256[] values; bytes[] payloads; bytes32 salt;
+ require hashOperationBatch(targets, values, payloads, predecessor, salt) == id; // Correlation
+ executeBatch@withrevert(e, targets, values, payloads, predecessor, salt);
+ } else {
+ calldataarg args;
+ f@withrevert(e, args);
+ }
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Definitions โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+definition DONE_TIMESTAMP() returns uint256 = 1;
+definition UNSET() returns uint8 = 0x1;
+definition PENDING() returns uint8 = 0x2;
+definition DONE() returns uint8 = 0x4;
+
+definition isUnset(env e, bytes32 id) returns bool = !isOperation(e, id);
+definition isPending(env e, bytes32 id) returns bool = isOperationPending(e, id);
+definition isDone(env e, bytes32 id) returns bool = isOperationDone(e, id);
+definition state(env e, bytes32 id) returns uint8 = (isUnset(e, id) ? UNSET() : 0) | (isPending(e, id) ? PENDING() : 0) | (isDone(e, id) ? DONE() : 0);
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariants: consistency of accessors โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant isOperationCheck(env e, bytes32 id)
+ isOperation(e, id) <=> getTimestamp(id) > 0
+ filtered { f -> !f.isView }
+
+invariant isOperationPendingCheck(env e, bytes32 id)
+ isOperationPending(e, id) <=> getTimestamp(id) > DONE_TIMESTAMP()
+ filtered { f -> !f.isView }
+
+invariant isOperationDoneCheck(env e, bytes32 id)
+ isOperationDone(e, id) <=> getTimestamp(id) == DONE_TIMESTAMP()
+ filtered { f -> !f.isView }
+
+invariant isOperationReadyCheck(env e, bytes32 id)
+ isOperationReady(e, id) <=> (isOperationPending(e, id) && getTimestamp(id) <= e.block.timestamp)
+ filtered { f -> !f.isView }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Invariant: a proposal id is either unset, pending or done โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+invariant stateConsistency(bytes32 id, env e)
+ // Check states are mutually exclusive
+ (isUnset(e, id) <=> (!isPending(e, id) && !isDone(e, id) )) &&
+ (isPending(e, id) <=> (!isUnset(e, id) && !isDone(e, id) )) &&
+ (isDone(e, id) <=> (!isUnset(e, id) && !isPending(e, id))) &&
+ // Check that the state helper behaves as expected:
+ (isUnset(e, id) <=> state(e, id) == UNSET() ) &&
+ (isPending(e, id) <=> state(e, id) == PENDING() ) &&
+ (isDone(e, id) <=> state(e, id) == DONE() ) &&
+ // Check substate
+ isOperationReady(e, id) => isPending(e, id)
+ filtered { f -> !f.isView }
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: state transition rules โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule stateTransition(bytes32 id, env e, method f, calldataarg args) {
+ require e.block.timestamp > 1; // Sanity
+
+ uint8 stateBefore = state(e, id);
+ f(e, args);
+ uint8 stateAfter = state(e, id);
+
+ // Cannot jump from UNSET to DONE
+ assert stateBefore == UNSET() => stateAfter != DONE();
+
+ // UNSET โ PENDING: schedule or scheduleBatch
+ assert stateBefore == UNSET() && stateAfter == PENDING() => (
+ f.selector == sig:schedule(address, uint256, bytes, bytes32, bytes32, uint256).selector ||
+ f.selector == sig:scheduleBatch(address[], uint256[], bytes[], bytes32, bytes32, uint256).selector
+ );
+
+ // PENDING โ UNSET: cancel
+ assert stateBefore == PENDING() && stateAfter == UNSET() => (
+ f.selector == sig:cancel(bytes32).selector
+ );
+
+ // PENDING โ DONE: execute or executeBatch
+ assert stateBefore == PENDING() && stateAfter == DONE() => (
+ f.selector == sig:execute(address, uint256, bytes, bytes32, bytes32).selector ||
+ f.selector == sig:executeBatch(address[], uint256[], bytes[], bytes32, bytes32).selector
+ );
+
+ // DONE is final
+ assert stateBefore == DONE() => stateAfter == DONE();
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: minimum delay can only be updated through a timelock execution โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule minDelayOnlyChange(env e) {
+ uint256 delayBefore = getMinDelay();
+
+ method f; calldataarg args;
+ f(e, args);
+
+ assert delayBefore != getMinDelay() => (e.msg.sender == currentContract && f.selector == sig:updateDelay(uint256).selector), "Unauthorized delay update";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: schedule liveness and effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule schedule(env e, method f, bytes32 id, uint256 delay) filtered { f ->
+ f.selector == sig:schedule(address, uint256, bytes, bytes32, bytes32, uint256).selector ||
+ f.selector == sig:scheduleBatch(address[], uint256[], bytes[], bytes32, bytes32, uint256).selector
+} {
+ require nonpayable(e);
+
+ // Basic timestamp assumptions
+ require e.block.timestamp > 1;
+ require e.block.timestamp + delay < max_uint256;
+ require e.block.timestamp + getMinDelay() < max_uint256;
+
+ bytes32 otherId; uint256 otherTimestamp = getTimestamp(otherId);
+
+ uint8 stateBefore = state(e, id);
+ bool isDelaySufficient = delay >= getMinDelay();
+ bool isProposerBefore = hasRole(PROPOSER_ROLE(), e.msg.sender);
+
+ helperScheduleWithRevert(e, f, id, delay);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ stateBefore == UNSET() &&
+ isDelaySufficient &&
+ isProposerBefore
+ );
+
+ // effect
+ assert success => state(e, id) == PENDING(), "State transition violation";
+ assert success => getTimestamp(id) == require_uint256(e.block.timestamp + delay), "Proposal timestamp not correctly set";
+
+ // no side effect
+ assert otherTimestamp != getTimestamp(otherId) => id == otherId, "Other proposal affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: execute liveness and effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule execute(env e, method f, bytes32 id, bytes32 predecessor) filtered { f ->
+ f.selector == sig:execute(address, uint256, bytes, bytes32, bytes32).selector ||
+ f.selector == sig:executeBatch(address[], uint256[], bytes[], bytes32, bytes32).selector
+} {
+ bytes32 otherId; uint256 otherTimestamp = getTimestamp(otherId);
+
+ uint8 stateBefore = state(e, id);
+ bool isOperationReadyBefore = isOperationReady(e, id);
+ bool isExecutorOrOpen = hasRole(EXECUTOR_ROLE(), e.msg.sender) || hasRole(EXECUTOR_ROLE(), 0);
+ bool predecessorDependency = predecessor == to_bytes32(0) || isDone(e, predecessor);
+
+ helperExecuteWithRevert(e, f, id, predecessor);
+ bool success = !lastReverted;
+
+ // The underlying transaction can revert, and that would cause the execution to revert. We can check that all non
+ // reverting calls meet the requirements in terms of proposal readiness, access control and predecessor dependency.
+ // We can't however guarantee that these requirements being meet ensure liveness of the proposal, because the
+ // proposal can revert for reasons beyond our control.
+
+ // liveness, should be `<=>` but can only check `=>` (see comment above)
+ assert success => (
+ stateBefore == PENDING() &&
+ isOperationReadyBefore &&
+ predecessorDependency &&
+ isExecutorOrOpen
+ );
+
+ // effect
+ assert success => state(e, id) == DONE(), "State transition violation";
+
+ // no side effect
+ assert otherTimestamp != getTimestamp(otherId) => id == otherId, "Other proposal affected";
+}
+
+/*
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+โ Rule: cancel liveness and effects โ
+โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
+*/
+rule cancel(env e, bytes32 id) {
+ require nonpayable(e);
+
+ bytes32 otherId; uint256 otherTimestamp = getTimestamp(otherId);
+
+ uint8 stateBefore = state(e, id);
+ bool isCanceller = hasRole(CANCELLER_ROLE(), e.msg.sender);
+
+ cancel@withrevert(e, id);
+ bool success = !lastReverted;
+
+ // liveness
+ assert success <=> (
+ stateBefore == PENDING() &&
+ isCanceller
+ );
+
+ // effect
+ assert success => state(e, id) == UNSET(), "State transition violation";
+
+ // no side effect
+ assert otherTimestamp != getTimestamp(otherId) => id == otherId, "Other proposal affected";
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/helpers/helpers.spec b/con/lib/openzeppelin-contracts/certora/specs/helpers/helpers.spec
new file mode 100644
index 000000000..7125ce2d8
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/helpers/helpers.spec
@@ -0,0 +1,12 @@
+// environment
+definition nonpayable(env e) returns bool = e.msg.value == 0;
+definition nonzerosender(env e) returns bool = e.msg.sender != 0;
+definition sanity(env e) returns bool = clock(e) > 0 && clock(e) <= max_uint48;
+
+// math
+definition min(mathint a, mathint b) returns mathint = a < b ? a : b;
+definition max(mathint a, mathint b) returns mathint = a > b ? a : b;
+
+// time
+definition clock(env e) returns mathint = to_mathint(e.block.timestamp);
+definition isSetAndPast(env e, uint48 timepoint) returns bool = timepoint != 0 && to_mathint(timepoint) <= clock(e);
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessControl.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessControl.spec
new file mode 100644
index 000000000..5c395b088
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessControl.spec
@@ -0,0 +1,8 @@
+methods {
+ function DEFAULT_ADMIN_ROLE() external returns (bytes32) envfree;
+ function hasRole(bytes32, address) external returns(bool) envfree;
+ function getRoleAdmin(bytes32) external returns(bytes32) envfree;
+ function grantRole(bytes32, address) external;
+ function revokeRole(bytes32, address) external;
+ function renounceRole(bytes32, address) external;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessControlDefaultAdminRules.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessControlDefaultAdminRules.spec
new file mode 100644
index 000000000..d02db180d
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessControlDefaultAdminRules.spec
@@ -0,0 +1,36 @@
+import "./IERC5313.spec";
+
+methods {
+ // === View ==
+
+ // Default Admin
+ function defaultAdmin() external returns(address) envfree;
+ function pendingDefaultAdmin() external returns(address, uint48) envfree;
+
+ // Default Admin Delay
+ function defaultAdminDelay() external returns(uint48);
+ function pendingDefaultAdminDelay() external returns(uint48, uint48);
+ function defaultAdminDelayIncreaseWait() external returns(uint48) envfree;
+
+ // === Mutations ==
+
+ // Default Admin
+ function beginDefaultAdminTransfer(address) external;
+ function cancelDefaultAdminTransfer() external;
+ function acceptDefaultAdminTransfer() external;
+
+ // Default Admin Delay
+ function changeDefaultAdminDelay(uint48) external;
+ function rollbackDefaultAdminDelay() external;
+
+ // == FV ==
+
+ // Default Admin
+ function pendingDefaultAdmin_() external returns (address) envfree;
+ function pendingDefaultAdminSchedule_() external returns (uint48) envfree;
+
+ // Default Admin Delay
+ function pendingDelay_() external returns (uint48);
+ function pendingDelaySchedule_() external returns (uint48);
+ function delayChangeWait_(uint48) external returns (uint48);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessManaged.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessManaged.spec
new file mode 100644
index 000000000..886d917d4
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessManaged.spec
@@ -0,0 +1,5 @@
+methods {
+ function authority() external returns (address) envfree;
+ function isConsumingScheduledOp() external returns (bytes4) envfree;
+ function setAuthority(address) external;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessManager.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessManager.spec
new file mode 100644
index 000000000..5d305f7b4
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IAccessManager.spec
@@ -0,0 +1,33 @@
+methods {
+ function ADMIN_ROLE() external returns (uint64) envfree;
+ function PUBLIC_ROLE() external returns (uint64) envfree;
+ function canCall(address,address,bytes4) external returns (bool,uint32);
+ function expiration() external returns (uint32) envfree;
+ function minSetback() external returns (uint32) envfree;
+ function isTargetClosed(address) external returns (bool) envfree;
+ function getTargetFunctionRole(address,bytes4) external returns (uint64) envfree;
+ function getTargetAdminDelay(address) external returns (uint32);
+ function getRoleAdmin(uint64) external returns (uint64) envfree;
+ function getRoleGuardian(uint64) external returns (uint64) envfree;
+ function getRoleGrantDelay(uint64) external returns (uint32);
+ function getAccess(uint64,address) external returns (uint48,uint32,uint32,uint48);
+ function hasRole(uint64,address) external returns (bool,uint32);
+ function labelRole(uint64,string) external;
+ function grantRole(uint64,address,uint32) external;
+ function revokeRole(uint64,address) external;
+ function renounceRole(uint64,address) external;
+ function setRoleAdmin(uint64,uint64) external;
+ function setRoleGuardian(uint64,uint64) external;
+ function setGrantDelay(uint64,uint32) external;
+ function setTargetFunctionRole(address,bytes4[],uint64) external;
+ function setTargetAdminDelay(address,uint32) external;
+ function setTargetClosed(address,bool) external;
+ function hashOperation(address,address,bytes) external returns (bytes32) envfree;
+ function getNonce(bytes32) external returns (uint32) envfree;
+ function getSchedule(bytes32) external returns (uint48);
+ function schedule(address,bytes,uint48) external returns (bytes32,uint32);
+ function execute(address,bytes) external returns (uint32);
+ function cancel(address,address,bytes) external returns (uint32);
+ function consumeScheduledOp(address,bytes) external;
+ function updateAuthority(address,address) external;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC20.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC20.spec
new file mode 100644
index 000000000..100901a04
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC20.spec
@@ -0,0 +1,11 @@
+methods {
+ function name() external returns (string) envfree;
+ function symbol() external returns (string) envfree;
+ function decimals() external returns (uint8) envfree;
+ function totalSupply() external returns (uint256) envfree;
+ function balanceOf(address) external returns (uint256) envfree;
+ function allowance(address,address) external returns (uint256) envfree;
+ function approve(address,uint256) external returns (bool);
+ function transfer(address,uint256) external returns (bool);
+ function transferFrom(address,address,uint256) external returns (bool);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC2612.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC2612.spec
new file mode 100644
index 000000000..4ecc17b49
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC2612.spec
@@ -0,0 +1,5 @@
+methods {
+ function permit(address,address,uint256,uint256,uint8,bytes32,bytes32) external;
+ function nonces(address) external returns (uint256) envfree;
+ function DOMAIN_SEPARATOR() external returns (bytes32) envfree;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC3156FlashBorrower.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC3156FlashBorrower.spec
new file mode 100644
index 000000000..733c168c7
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC3156FlashBorrower.spec
@@ -0,0 +1,3 @@
+methods {
+ function _.onFlashLoan(address,address,uint256,uint256,bytes) external => DISPATCHER(true);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC3156FlashLender.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC3156FlashLender.spec
new file mode 100644
index 000000000..66ed14cd1
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC3156FlashLender.spec
@@ -0,0 +1,5 @@
+methods {
+ function maxFlashLoan(address) external returns (uint256) envfree;
+ function flashFee(address,uint256) external returns (uint256) envfree;
+ function flashLoan(address,address,uint256,bytes) external returns (bool);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC5313.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC5313.spec
new file mode 100644
index 000000000..f1d469faf
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC5313.spec
@@ -0,0 +1,3 @@
+methods {
+ function owner() external returns (address) envfree;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC721.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC721.spec
new file mode 100644
index 000000000..34ff50bd1
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC721.spec
@@ -0,0 +1,17 @@
+methods {
+ // IERC721
+ function balanceOf(address) external returns (uint256) envfree;
+ function ownerOf(uint256) external returns (address) envfree;
+ function getApproved(uint256) external returns (address) envfree;
+ function isApprovedForAll(address,address) external returns (bool) envfree;
+ function safeTransferFrom(address,address,uint256,bytes) external;
+ function safeTransferFrom(address,address,uint256) external;
+ function transferFrom(address,address,uint256) external;
+ function approve(address,uint256) external;
+ function setApprovalForAll(address,bool) external;
+
+ // IERC721Metadata
+ function name() external returns (string);
+ function symbol() external returns (string);
+ function tokenURI(uint256) external returns (string);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IERC721Receiver.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC721Receiver.spec
new file mode 100644
index 000000000..e6bdf4283
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IERC721Receiver.spec
@@ -0,0 +1,3 @@
+methods {
+ function _.onERC721Received(address,address,uint256,bytes) external => DISPATCHER(true);
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IOwnable.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IOwnable.spec
new file mode 100644
index 000000000..4d7c925c5
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IOwnable.spec
@@ -0,0 +1,5 @@
+methods {
+ function owner() external returns (address) envfree;
+ function transferOwnership(address) external;
+ function renounceOwnership() external;
+}
diff --git a/con/lib/openzeppelin-contracts/certora/specs/methods/IOwnable2Step.spec b/con/lib/openzeppelin-contracts/certora/specs/methods/IOwnable2Step.spec
new file mode 100644
index 000000000..e6a99570a
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/certora/specs/methods/IOwnable2Step.spec
@@ -0,0 +1,7 @@
+methods {
+ function owner() external returns (address) envfree;
+ function pendingOwner() external returns (address) envfree;
+ function transferOwnership(address) external;
+ function acceptOwnership() external;
+ function renounceOwnership() external;
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/AccessControl.sol b/con/lib/openzeppelin-contracts/contracts/access/AccessControl.sol
new file mode 100644
index 000000000..0c7ec6093
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/AccessControl.sol
@@ -0,0 +1,207 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/AccessControl.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAccessControl} from "./IAccessControl.sol";
+import {Context} from "../utils/Context.sol";
+import {IERC165, ERC165} from "../utils/introspection/ERC165.sol";
+
+/**
+ * @dev Contract module that allows children to implement role-based access
+ * control mechanisms. This is a lightweight version that doesn't allow enumerating role
+ * members except through off-chain means by accessing the contract event logs. Some
+ * applications may benefit from on-chain enumerability, for those cases see
+ * {AccessControlEnumerable}.
+ *
+ * Roles are referred to by their `bytes32` identifier. These should be exposed
+ * in the external API and be unique. The best way to achieve this is by
+ * using `public constant` hash digests:
+ *
+ * ```solidity
+ * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
+ * ```
+ *
+ * Roles can be used to represent a set of permissions. To restrict access to a
+ * function call, use {hasRole}:
+ *
+ * ```solidity
+ * function foo() public {
+ * require(hasRole(MY_ROLE, msg.sender));
+ * ...
+ * }
+ * ```
+ *
+ * Roles can be granted and revoked dynamically via the {grantRole} and
+ * {revokeRole} functions. Each role has an associated admin role, and only
+ * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
+ *
+ * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
+ * that only accounts with this role will be able to grant or revoke other
+ * roles. More complex role relationships can be created by using
+ * {_setRoleAdmin}.
+ *
+ * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
+ * grant and revoke this role. Extra precautions should be taken to secure
+ * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
+ * to enforce additional security measures for this role.
+ */
+abstract contract AccessControl is Context, IAccessControl, ERC165 {
+ struct RoleData {
+ mapping(address account => bool) hasRole;
+ bytes32 adminRole;
+ }
+
+ mapping(bytes32 role => RoleData) private _roles;
+
+ bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
+
+ /**
+ * @dev Modifier that checks that an account has a specific role. Reverts
+ * with an {AccessControlUnauthorizedAccount} error including the required role.
+ */
+ modifier onlyRole(bytes32 role) {
+ _checkRole(role);
+ _;
+ }
+
+ /// @inheritdoc IERC165
+ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
+ }
+
+ /**
+ * @dev Returns `true` if `account` has been granted `role`.
+ */
+ function hasRole(bytes32 role, address account) public view virtual returns (bool) {
+ return _roles[role].hasRole[account];
+ }
+
+ /**
+ * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
+ * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
+ */
+ function _checkRole(bytes32 role) internal view virtual {
+ _checkRole(role, _msgSender());
+ }
+
+ /**
+ * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
+ * is missing `role`.
+ */
+ function _checkRole(bytes32 role, address account) internal view virtual {
+ if (!hasRole(role, account)) {
+ revert AccessControlUnauthorizedAccount(account, role);
+ }
+ }
+
+ /**
+ * @dev Returns the admin role that controls `role`. See {grantRole} and
+ * {revokeRole}.
+ *
+ * To change a role's admin, use {_setRoleAdmin}.
+ */
+ function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
+ return _roles[role].adminRole;
+ }
+
+ /**
+ * @dev Grants `role` to `account`.
+ *
+ * If `account` had not been already granted `role`, emits a {RoleGranted}
+ * event.
+ *
+ * Requirements:
+ *
+ * - the caller must have ``role``'s admin role.
+ *
+ * May emit a {RoleGranted} event.
+ */
+ function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
+ _grantRole(role, account);
+ }
+
+ /**
+ * @dev Revokes `role` from `account`.
+ *
+ * If `account` had been granted `role`, emits a {RoleRevoked} event.
+ *
+ * Requirements:
+ *
+ * - the caller must have ``role``'s admin role.
+ *
+ * May emit a {RoleRevoked} event.
+ */
+ function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
+ _revokeRole(role, account);
+ }
+
+ /**
+ * @dev Revokes `role` from the calling account.
+ *
+ * Roles are often managed via {grantRole} and {revokeRole}: this function's
+ * purpose is to provide a mechanism for accounts to lose their privileges
+ * if they are compromised (such as when a trusted device is misplaced).
+ *
+ * If the calling account had been revoked `role`, emits a {RoleRevoked}
+ * event.
+ *
+ * Requirements:
+ *
+ * - the caller must be `callerConfirmation`.
+ *
+ * May emit a {RoleRevoked} event.
+ */
+ function renounceRole(bytes32 role, address callerConfirmation) public virtual {
+ if (callerConfirmation != _msgSender()) {
+ revert AccessControlBadConfirmation();
+ }
+
+ _revokeRole(role, callerConfirmation);
+ }
+
+ /**
+ * @dev Sets `adminRole` as ``role``'s admin role.
+ *
+ * Emits a {RoleAdminChanged} event.
+ */
+ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
+ bytes32 previousAdminRole = getRoleAdmin(role);
+ _roles[role].adminRole = adminRole;
+ emit RoleAdminChanged(role, previousAdminRole, adminRole);
+ }
+
+ /**
+ * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
+ *
+ * Internal function without access restriction.
+ *
+ * May emit a {RoleGranted} event.
+ */
+ function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
+ if (!hasRole(role, account)) {
+ _roles[role].hasRole[account] = true;
+ emit RoleGranted(role, account, _msgSender());
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * @dev Attempts to revoke `role` from `account` and returns a boolean indicating if `role` was revoked.
+ *
+ * Internal function without access restriction.
+ *
+ * May emit a {RoleRevoked} event.
+ */
+ function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
+ if (hasRole(role, account)) {
+ _roles[role].hasRole[account] = false;
+ emit RoleRevoked(role, account, _msgSender());
+ return true;
+ } else {
+ return false;
+ }
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol b/con/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol
new file mode 100644
index 000000000..23f0770a0
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/IAccessControl.sol
@@ -0,0 +1,98 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/IAccessControl.sol)
+
+pragma solidity >=0.8.4;
+
+/**
+ * @dev External interface of AccessControl declared to support ERC-165 detection.
+ */
+interface IAccessControl {
+ /**
+ * @dev The `account` is missing a role.
+ */
+ error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
+
+ /**
+ * @dev The caller of a function is not the expected one.
+ *
+ * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
+ */
+ error AccessControlBadConfirmation();
+
+ /**
+ * @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 to signal this.
+ */
+ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
+
+ /**
+ * @dev Emitted when `account` is granted `role`.
+ *
+ * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
+ * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
+ */
+ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
+
+ /**
+ * @dev Emitted when `account` is revoked `role`.
+ *
+ * `sender` is the account that originated the contract call:
+ * - if using `revokeRole`, it is the admin role bearer
+ * - if using `renounceRole`, it is the role bearer (i.e. `account`)
+ */
+ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
+
+ /**
+ * @dev Returns `true` if `account` has been granted `role`.
+ */
+ function hasRole(bytes32 role, address account) external view returns (bool);
+
+ /**
+ * @dev Returns the admin role that controls `role`. See {grantRole} and
+ * {revokeRole}.
+ *
+ * To change a role's admin, use {AccessControl-_setRoleAdmin}.
+ */
+ function getRoleAdmin(bytes32 role) external view returns (bytes32);
+
+ /**
+ * @dev Grants `role` to `account`.
+ *
+ * If `account` had not been already granted `role`, emits a {RoleGranted}
+ * event.
+ *
+ * Requirements:
+ *
+ * - the caller must have ``role``'s admin role.
+ */
+ function grantRole(bytes32 role, address account) external;
+
+ /**
+ * @dev Revokes `role` from `account`.
+ *
+ * If `account` had been granted `role`, emits a {RoleRevoked} event.
+ *
+ * Requirements:
+ *
+ * - the caller must have ``role``'s admin role.
+ */
+ function revokeRole(bytes32 role, address account) external;
+
+ /**
+ * @dev Revokes `role` from the calling account.
+ *
+ * Roles are often managed via {grantRole} and {revokeRole}: this function's
+ * purpose is to provide a mechanism for accounts to lose their privileges
+ * if they are compromised (such as when a trusted device is misplaced).
+ *
+ * If the calling account had been granted `role`, emits a {RoleRevoked}
+ * event.
+ *
+ * Requirements:
+ *
+ * - the caller must be `callerConfirmation`.
+ */
+ function renounceRole(bytes32 role, address callerConfirmation) external;
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/Ownable.sol b/con/lib/openzeppelin-contracts/contracts/access/Ownable.sol
new file mode 100644
index 000000000..bd96f6661
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/Ownable.sol
@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)
+
+pragma solidity ^0.8.20;
+
+import {Context} from "../utils/Context.sol";
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * The initial owner is set to the address provided by the deployer. This can
+ * later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context {
+ address private _owner;
+
+ /**
+ * @dev The caller account is not authorized to perform an operation.
+ */
+ error OwnableUnauthorizedAccount(address account);
+
+ /**
+ * @dev The owner is not a valid owner account. (eg. `address(0)`)
+ */
+ error OwnableInvalidOwner(address owner);
+
+ event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+ /**
+ * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
+ */
+ constructor(address initialOwner) {
+ if (initialOwner == address(0)) {
+ revert OwnableInvalidOwner(address(0));
+ }
+ _transferOwnership(initialOwner);
+ }
+
+ /**
+ * @dev Throws if called by any account other than the owner.
+ */
+ modifier onlyOwner() {
+ _checkOwner();
+ _;
+ }
+
+ /**
+ * @dev Returns the address of the current owner.
+ */
+ function owner() public view virtual returns (address) {
+ return _owner;
+ }
+
+ /**
+ * @dev Throws if the sender is not the owner.
+ */
+ function _checkOwner() internal view virtual {
+ if (owner() != _msgSender()) {
+ revert OwnableUnauthorizedAccount(_msgSender());
+ }
+ }
+
+ /**
+ * @dev Leaves the contract without owner. It will not be possible to call
+ * `onlyOwner` functions. Can only be called by the current owner.
+ *
+ * NOTE: Renouncing ownership will leave the contract without an owner,
+ * thereby disabling any functionality that is only available to the owner.
+ */
+ function renounceOwnership() public virtual onlyOwner {
+ _transferOwnership(address(0));
+ }
+
+ /**
+ * @dev Transfers ownership of the contract to a new account (`newOwner`).
+ * Can only be called by the current owner.
+ */
+ function transferOwnership(address newOwner) public virtual onlyOwner {
+ if (newOwner == address(0)) {
+ revert OwnableInvalidOwner(address(0));
+ }
+ _transferOwnership(newOwner);
+ }
+
+ /**
+ * @dev Transfers ownership of the contract to a new account (`newOwner`).
+ * Internal function without access restriction.
+ */
+ function _transferOwnership(address newOwner) internal virtual {
+ address oldOwner = _owner;
+ _owner = newOwner;
+ emit OwnershipTransferred(oldOwner, newOwner);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol b/con/lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol
new file mode 100644
index 000000000..3a0747ce7
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/Ownable2Step.sol
@@ -0,0 +1,67 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.1.0) (access/Ownable2Step.sol)
+
+pragma solidity ^0.8.20;
+
+import {Ownable} from "./Ownable.sol";
+
+/**
+ * @dev Contract module which provides access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * This extension of the {Ownable} contract includes a two-step mechanism to transfer
+ * ownership, where the new owner must call {acceptOwnership} in order to replace the
+ * old one. This can help prevent common mistakes, such as transfers of ownership to
+ * incorrect accounts, or to contracts that are unable to interact with the
+ * permission system.
+ *
+ * The initial owner is specified at deployment time in the constructor for `Ownable`. This
+ * can later be changed with {transferOwnership} and {acceptOwnership}.
+ *
+ * This module is used through inheritance. It will make available all functions
+ * from parent (Ownable).
+ */
+abstract contract Ownable2Step is Ownable {
+ address private _pendingOwner;
+
+ event OwnershipTransferStarted(address indexed previousOwner, address indexed newOwner);
+
+ /**
+ * @dev Returns the address of the pending owner.
+ */
+ function pendingOwner() public view virtual returns (address) {
+ return _pendingOwner;
+ }
+
+ /**
+ * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
+ * Can only be called by the current owner.
+ *
+ * Setting `newOwner` to the zero address is allowed; this can be used to cancel an initiated ownership transfer.
+ */
+ function transferOwnership(address newOwner) public virtual override onlyOwner {
+ _pendingOwner = newOwner;
+ emit OwnershipTransferStarted(owner(), newOwner);
+ }
+
+ /**
+ * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
+ * Internal function without access restriction.
+ */
+ function _transferOwnership(address newOwner) internal virtual override {
+ delete _pendingOwner;
+ super._transferOwnership(newOwner);
+ }
+
+ /**
+ * @dev The new owner accepts the ownership transfer.
+ */
+ function acceptOwnership() public virtual {
+ address sender = _msgSender();
+ if (pendingOwner() != sender) {
+ revert OwnableUnauthorizedAccount(sender);
+ }
+ _transferOwnership(sender);
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/README.adoc b/con/lib/openzeppelin-contracts/contracts/access/README.adoc
new file mode 100644
index 000000000..b89865b2c
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/README.adoc
@@ -0,0 +1,45 @@
+= Access Control
+
+[.readme-notice]
+NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/access
+
+This directory provides ways to restrict who can access the functions of a contract or when they can do it.
+
+- {AccessManager} is a full-fledged access control solution for smart contract systems. Allows creating and assigning multiple hierarchical roles with execution delays for each account across various contracts.
+- {AccessManaged} delegates its access control to an authority that dictates the permissions of the managed contract. It's compatible with an AccessManager as an authority.
+- {AccessControl} provides a per-contract role based access control mechanism. Multiple hierarchical roles can be created and assigned each to multiple accounts within the same instance.
+- {Ownable} is a simpler mechanism with a single owner "role" that can be assigned to a single account. This simpler mechanism can be useful for quick tests but projects with production concerns are likely to outgrow it.
+
+== Core
+
+{{Ownable}}
+
+{{Ownable2Step}}
+
+{{IAccessControl}}
+
+{{AccessControl}}
+
+== Extensions
+
+{{IAccessControlEnumerable}}
+
+{{AccessControlEnumerable}}
+
+{{IAccessControlDefaultAdminRules}}
+
+{{AccessControlDefaultAdminRules}}
+
+== AccessManager
+
+{{IAuthority}}
+
+{{IAccessManager}}
+
+{{AccessManager}}
+
+{{IAccessManaged}}
+
+{{AccessManaged}}
+
+{{AuthorityUtils}}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/extensions/AccessControlDefaultAdminRules.sol b/con/lib/openzeppelin-contracts/contracts/access/extensions/AccessControlDefaultAdminRules.sol
new file mode 100644
index 000000000..77a7e45bd
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/extensions/AccessControlDefaultAdminRules.sol
@@ -0,0 +1,372 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/AccessControlDefaultAdminRules.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAccessControlDefaultAdminRules} from "./IAccessControlDefaultAdminRules.sol";
+import {AccessControl, IAccessControl} from "../AccessControl.sol";
+import {SafeCast} from "../../utils/math/SafeCast.sol";
+import {Math} from "../../utils/math/Math.sol";
+import {IERC5313} from "../../interfaces/IERC5313.sol";
+import {IERC165} from "../../utils/introspection/ERC165.sol";
+
+/**
+ * @dev Extension of {AccessControl} that allows specifying special rules to manage
+ * the `DEFAULT_ADMIN_ROLE` holder, which is a sensitive role with special permissions
+ * over other roles that may potentially have privileged rights in the system.
+ *
+ * If a specific role doesn't have an admin role assigned, the holder of the
+ * `DEFAULT_ADMIN_ROLE` will have the ability to grant it and revoke it.
+ *
+ * This contract implements the following risk mitigations on top of {AccessControl}:
+ *
+ * * Only one account holds the `DEFAULT_ADMIN_ROLE` since deployment until it's potentially renounced.
+ * * Enforces a 2-step process to transfer the `DEFAULT_ADMIN_ROLE` to another account.
+ * * Enforces a configurable delay between the two steps, with the ability to cancel before the transfer is accepted.
+ * * The delay can be changed by scheduling, see {changeDefaultAdminDelay}.
+ * * Role transfers must wait at least one block after scheduling before it can be accepted.
+ * * It is not possible to use another role to manage the `DEFAULT_ADMIN_ROLE`.
+ *
+ * Example usage:
+ *
+ * ```solidity
+ * contract MyToken is AccessControlDefaultAdminRules {
+ * constructor() AccessControlDefaultAdminRules(
+ * 3 days,
+ * msg.sender // Explicit initial `DEFAULT_ADMIN_ROLE` holder
+ * ) {}
+ * }
+ * ```
+ */
+abstract contract AccessControlDefaultAdminRules is IAccessControlDefaultAdminRules, IERC5313, AccessControl {
+ // pending admin pair read/written together frequently
+ address private _pendingDefaultAdmin;
+ uint48 private _pendingDefaultAdminSchedule; // 0 == unset
+
+ uint48 private _currentDelay;
+ address private _currentDefaultAdmin;
+
+ // pending delay pair read/written together frequently
+ uint48 private _pendingDelay;
+ uint48 private _pendingDelaySchedule; // 0 == unset
+
+ /**
+ * @dev Sets the initial values for {defaultAdminDelay} and {defaultAdmin} address.
+ */
+ constructor(uint48 initialDelay, address initialDefaultAdmin) {
+ if (initialDefaultAdmin == address(0)) {
+ revert AccessControlInvalidDefaultAdmin(address(0));
+ }
+ _currentDelay = initialDelay;
+ _grantRole(DEFAULT_ADMIN_ROLE, initialDefaultAdmin);
+ }
+
+ /// @inheritdoc IERC165
+ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ return interfaceId == type(IAccessControlDefaultAdminRules).interfaceId || super.supportsInterface(interfaceId);
+ }
+
+ /// @inheritdoc IERC5313
+ function owner() public view virtual returns (address) {
+ return defaultAdmin();
+ }
+
+ ///
+ /// Override AccessControl role management
+ ///
+
+ /**
+ * @dev See {AccessControl-grantRole}. Reverts for `DEFAULT_ADMIN_ROLE`.
+ */
+ function grantRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
+ if (role == DEFAULT_ADMIN_ROLE) {
+ revert AccessControlEnforcedDefaultAdminRules();
+ }
+ super.grantRole(role, account);
+ }
+
+ /**
+ * @dev See {AccessControl-revokeRole}. Reverts for `DEFAULT_ADMIN_ROLE`.
+ */
+ function revokeRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
+ if (role == DEFAULT_ADMIN_ROLE) {
+ revert AccessControlEnforcedDefaultAdminRules();
+ }
+ super.revokeRole(role, account);
+ }
+
+ /**
+ * @dev See {AccessControl-renounceRole}.
+ *
+ * For the `DEFAULT_ADMIN_ROLE`, it only allows renouncing in two steps by first calling
+ * {beginDefaultAdminTransfer} to the `address(0)`, so it's required that the {pendingDefaultAdmin} schedule
+ * has also passed when calling this function.
+ *
+ * After its execution, it will not be possible to call `onlyRole(DEFAULT_ADMIN_ROLE)` functions.
+ *
+ * NOTE: Renouncing `DEFAULT_ADMIN_ROLE` will leave the contract without a {defaultAdmin},
+ * thereby disabling any functionality that is only available for it, and the possibility of reassigning a
+ * non-administrated role.
+ */
+ function renounceRole(bytes32 role, address account) public virtual override(AccessControl, IAccessControl) {
+ if (role == DEFAULT_ADMIN_ROLE && account == defaultAdmin()) {
+ (address newDefaultAdmin, uint48 schedule) = pendingDefaultAdmin();
+ if (newDefaultAdmin != address(0) || !_isScheduleSet(schedule) || !_hasSchedulePassed(schedule)) {
+ revert AccessControlEnforcedDefaultAdminDelay(schedule);
+ }
+ delete _pendingDefaultAdminSchedule;
+ }
+ super.renounceRole(role, account);
+ }
+
+ /**
+ * @dev See {AccessControl-_grantRole}.
+ *
+ * For `DEFAULT_ADMIN_ROLE`, it only allows granting if there isn't already a {defaultAdmin} or if the
+ * role has been previously renounced.
+ *
+ * NOTE: Exposing this function through another mechanism may make the `DEFAULT_ADMIN_ROLE`
+ * assignable again. Make sure to guarantee this is the expected behavior in your implementation.
+ */
+ function _grantRole(bytes32 role, address account) internal virtual override returns (bool) {
+ if (role == DEFAULT_ADMIN_ROLE) {
+ if (defaultAdmin() != address(0)) {
+ revert AccessControlEnforcedDefaultAdminRules();
+ }
+ _currentDefaultAdmin = account;
+ }
+ return super._grantRole(role, account);
+ }
+
+ /// @inheritdoc AccessControl
+ function _revokeRole(bytes32 role, address account) internal virtual override returns (bool) {
+ if (role == DEFAULT_ADMIN_ROLE && account == defaultAdmin()) {
+ delete _currentDefaultAdmin;
+ }
+ return super._revokeRole(role, account);
+ }
+
+ /**
+ * @dev See {AccessControl-_setRoleAdmin}. Reverts for `DEFAULT_ADMIN_ROLE`.
+ */
+ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual override {
+ if (role == DEFAULT_ADMIN_ROLE) {
+ revert AccessControlEnforcedDefaultAdminRules();
+ }
+ super._setRoleAdmin(role, adminRole);
+ }
+
+ ///
+ /// AccessControlDefaultAdminRules accessors
+ ///
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function defaultAdmin() public view virtual returns (address) {
+ return _currentDefaultAdmin;
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function pendingDefaultAdmin() public view virtual returns (address newAdmin, uint48 schedule) {
+ return (_pendingDefaultAdmin, _pendingDefaultAdminSchedule);
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function defaultAdminDelay() public view virtual returns (uint48) {
+ uint48 schedule = _pendingDelaySchedule;
+ return (_isScheduleSet(schedule) && _hasSchedulePassed(schedule)) ? _pendingDelay : _currentDelay;
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function pendingDefaultAdminDelay() public view virtual returns (uint48 newDelay, uint48 schedule) {
+ schedule = _pendingDelaySchedule;
+ return (_isScheduleSet(schedule) && !_hasSchedulePassed(schedule)) ? (_pendingDelay, schedule) : (0, 0);
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function defaultAdminDelayIncreaseWait() public view virtual returns (uint48) {
+ return 5 days;
+ }
+
+ ///
+ /// AccessControlDefaultAdminRules public and internal setters for defaultAdmin/pendingDefaultAdmin
+ ///
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function beginDefaultAdminTransfer(address newAdmin) public virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+ _beginDefaultAdminTransfer(newAdmin);
+ }
+
+ /**
+ * @dev See {beginDefaultAdminTransfer}.
+ *
+ * Internal function without access restriction.
+ */
+ function _beginDefaultAdminTransfer(address newAdmin) internal virtual {
+ uint48 newSchedule = SafeCast.toUint48(block.timestamp) + defaultAdminDelay();
+ _setPendingDefaultAdmin(newAdmin, newSchedule);
+ emit DefaultAdminTransferScheduled(newAdmin, newSchedule);
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function cancelDefaultAdminTransfer() public virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+ _cancelDefaultAdminTransfer();
+ }
+
+ /**
+ * @dev See {cancelDefaultAdminTransfer}.
+ *
+ * Internal function without access restriction.
+ */
+ function _cancelDefaultAdminTransfer() internal virtual {
+ _setPendingDefaultAdmin(address(0), 0);
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function acceptDefaultAdminTransfer() public virtual {
+ (address newDefaultAdmin, ) = pendingDefaultAdmin();
+ if (_msgSender() != newDefaultAdmin) {
+ // Enforce newDefaultAdmin explicit acceptance.
+ revert AccessControlInvalidDefaultAdmin(_msgSender());
+ }
+ _acceptDefaultAdminTransfer();
+ }
+
+ /**
+ * @dev See {acceptDefaultAdminTransfer}.
+ *
+ * Internal function without access restriction.
+ */
+ function _acceptDefaultAdminTransfer() internal virtual {
+ (address newAdmin, uint48 schedule) = pendingDefaultAdmin();
+ if (!_isScheduleSet(schedule) || !_hasSchedulePassed(schedule)) {
+ revert AccessControlEnforcedDefaultAdminDelay(schedule);
+ }
+ _revokeRole(DEFAULT_ADMIN_ROLE, defaultAdmin());
+ _grantRole(DEFAULT_ADMIN_ROLE, newAdmin);
+ delete _pendingDefaultAdmin;
+ delete _pendingDefaultAdminSchedule;
+ }
+
+ ///
+ /// AccessControlDefaultAdminRules public and internal setters for defaultAdminDelay/pendingDefaultAdminDelay
+ ///
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function changeDefaultAdminDelay(uint48 newDelay) public virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+ _changeDefaultAdminDelay(newDelay);
+ }
+
+ /**
+ * @dev See {changeDefaultAdminDelay}.
+ *
+ * Internal function without access restriction.
+ */
+ function _changeDefaultAdminDelay(uint48 newDelay) internal virtual {
+ uint48 newSchedule = SafeCast.toUint48(block.timestamp) + _delayChangeWait(newDelay);
+ _setPendingDelay(newDelay, newSchedule);
+ emit DefaultAdminDelayChangeScheduled(newDelay, newSchedule);
+ }
+
+ /// @inheritdoc IAccessControlDefaultAdminRules
+ function rollbackDefaultAdminDelay() public virtual onlyRole(DEFAULT_ADMIN_ROLE) {
+ _rollbackDefaultAdminDelay();
+ }
+
+ /**
+ * @dev See {rollbackDefaultAdminDelay}.
+ *
+ * Internal function without access restriction.
+ */
+ function _rollbackDefaultAdminDelay() internal virtual {
+ _setPendingDelay(0, 0);
+ }
+
+ /**
+ * @dev Returns the amount of seconds to wait after the `newDelay` will
+ * become the new {defaultAdminDelay}.
+ *
+ * The value returned guarantees that if the delay is reduced, it will go into effect
+ * after a wait that honors the previously set delay.
+ *
+ * See {defaultAdminDelayIncreaseWait}.
+ */
+ function _delayChangeWait(uint48 newDelay) internal view virtual returns (uint48) {
+ uint48 currentDelay = defaultAdminDelay();
+
+ // When increasing the delay, we schedule the delay change to occur after a period of "new delay" has passed, up
+ // to a maximum given by defaultAdminDelayIncreaseWait, by default 5 days. For example, if increasing from 1 day
+ // to 3 days, the new delay will come into effect after 3 days. If increasing from 1 day to 10 days, the new
+ // delay will come into effect after 5 days. The 5 day wait period is intended to be able to fix an error like
+ // using milliseconds instead of seconds.
+ //
+ // When decreasing the delay, we wait the difference between "current delay" and "new delay". This guarantees
+ // that an admin transfer cannot be made faster than "current delay" at the time the delay change is scheduled.
+ // For example, if decreasing from 10 days to 3 days, the new delay will come into effect after 7 days.
+ return
+ newDelay > currentDelay
+ ? uint48(Math.min(newDelay, defaultAdminDelayIncreaseWait())) // no need to safecast, both inputs are uint48
+ : currentDelay - newDelay;
+ }
+
+ ///
+ /// Private setters
+ ///
+
+ /**
+ * @dev Setter of the tuple for pending admin and its schedule.
+ *
+ * May emit a DefaultAdminTransferCanceled event.
+ */
+ function _setPendingDefaultAdmin(address newAdmin, uint48 newSchedule) private {
+ (, uint48 oldSchedule) = pendingDefaultAdmin();
+
+ _pendingDefaultAdmin = newAdmin;
+ _pendingDefaultAdminSchedule = newSchedule;
+
+ // An `oldSchedule` from `pendingDefaultAdmin()` is only set if it hasn't been accepted.
+ if (_isScheduleSet(oldSchedule)) {
+ // Emit for implicit cancellations when another default admin was scheduled.
+ emit DefaultAdminTransferCanceled();
+ }
+ }
+
+ /**
+ * @dev Setter of the tuple for pending delay and its schedule.
+ *
+ * May emit a DefaultAdminDelayChangeCanceled event.
+ */
+ function _setPendingDelay(uint48 newDelay, uint48 newSchedule) private {
+ uint48 oldSchedule = _pendingDelaySchedule;
+
+ if (_isScheduleSet(oldSchedule)) {
+ if (_hasSchedulePassed(oldSchedule)) {
+ // Materialize a virtual delay
+ _currentDelay = _pendingDelay;
+ } else {
+ // Emit for implicit cancellations when another delay was scheduled.
+ emit DefaultAdminDelayChangeCanceled();
+ }
+ }
+
+ _pendingDelay = newDelay;
+ _pendingDelaySchedule = newSchedule;
+ }
+
+ ///
+ /// Private helpers
+ ///
+
+ /**
+ * @dev Defines if an `schedule` is considered set. For consistency purposes.
+ */
+ function _isScheduleSet(uint48 schedule) private pure returns (bool) {
+ return schedule != 0;
+ }
+
+ /**
+ * @dev Defines if an `schedule` is considered passed. For consistency purposes.
+ */
+ function _hasSchedulePassed(uint48 schedule) private view returns (bool) {
+ return schedule < block.timestamp;
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/extensions/AccessControlEnumerable.sol b/con/lib/openzeppelin-contracts/contracts/access/extensions/AccessControlEnumerable.sol
new file mode 100644
index 000000000..f2d79fd57
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/extensions/AccessControlEnumerable.sol
@@ -0,0 +1,81 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/AccessControlEnumerable.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAccessControlEnumerable} from "./IAccessControlEnumerable.sol";
+import {AccessControl} from "../AccessControl.sol";
+import {EnumerableSet} from "../../utils/structs/EnumerableSet.sol";
+import {IERC165} from "../../utils/introspection/ERC165.sol";
+
+/**
+ * @dev Extension of {AccessControl} that allows enumerating the members of each role.
+ */
+abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
+ using EnumerableSet for EnumerableSet.AddressSet;
+
+ mapping(bytes32 role => EnumerableSet.AddressSet) private _roleMembers;
+
+ /// @inheritdoc IERC165
+ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
+ return interfaceId == type(IAccessControlEnumerable).interfaceId || super.supportsInterface(interfaceId);
+ }
+
+ /**
+ * @dev Returns one of the accounts that have `role`. `index` must be a
+ * value between 0 and {getRoleMemberCount}, non-inclusive.
+ *
+ * Role bearers are not sorted in any particular way, and their ordering may
+ * change at any point.
+ *
+ * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
+ * you perform all queries on the same block. See the following
+ * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
+ * for more information.
+ */
+ function getRoleMember(bytes32 role, uint256 index) public view virtual returns (address) {
+ return _roleMembers[role].at(index);
+ }
+
+ /**
+ * @dev Returns the number of accounts that have `role`. Can be used
+ * together with {getRoleMember} to enumerate all bearers of a role.
+ */
+ function getRoleMemberCount(bytes32 role) public view virtual returns (uint256) {
+ return _roleMembers[role].length();
+ }
+
+ /**
+ * @dev Return all accounts that have `role`
+ *
+ * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
+ * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
+ * this function has an unbounded cost, and using it as part of a state-changing function may render the function
+ * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
+ */
+ function getRoleMembers(bytes32 role) public view virtual returns (address[] memory) {
+ return _roleMembers[role].values();
+ }
+
+ /**
+ * @dev Overload {AccessControl-_grantRole} to track enumerable memberships
+ */
+ function _grantRole(bytes32 role, address account) internal virtual override returns (bool) {
+ bool granted = super._grantRole(role, account);
+ if (granted) {
+ _roleMembers[role].add(account);
+ }
+ return granted;
+ }
+
+ /**
+ * @dev Overload {AccessControl-_revokeRole} to track enumerable memberships
+ */
+ function _revokeRole(bytes32 role, address account) internal virtual override returns (bool) {
+ bool revoked = super._revokeRole(role, account);
+ if (revoked) {
+ _roleMembers[role].remove(account);
+ }
+ return revoked;
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/extensions/IAccessControlDefaultAdminRules.sol b/con/lib/openzeppelin-contracts/contracts/access/extensions/IAccessControlDefaultAdminRules.sol
new file mode 100644
index 000000000..616b4d8ae
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/extensions/IAccessControlDefaultAdminRules.sol
@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/IAccessControlDefaultAdminRules.sol)
+
+pragma solidity >=0.8.4;
+
+import {IAccessControl} from "../IAccessControl.sol";
+
+/**
+ * @dev External interface of AccessControlDefaultAdminRules declared to support ERC-165 detection.
+ */
+interface IAccessControlDefaultAdminRules is IAccessControl {
+ /**
+ * @dev The new default admin is not a valid default admin.
+ */
+ error AccessControlInvalidDefaultAdmin(address defaultAdmin);
+
+ /**
+ * @dev At least one of the following rules was violated:
+ *
+ * - The `DEFAULT_ADMIN_ROLE` must only be managed by itself.
+ * - The `DEFAULT_ADMIN_ROLE` must only be held by one account at the time.
+ * - Any `DEFAULT_ADMIN_ROLE` transfer must be in two delayed steps.
+ */
+ error AccessControlEnforcedDefaultAdminRules();
+
+ /**
+ * @dev The delay for transferring the default admin delay is enforced and
+ * the operation must wait until `schedule`.
+ *
+ * NOTE: `schedule` can be 0 indicating there's no transfer scheduled.
+ */
+ error AccessControlEnforcedDefaultAdminDelay(uint48 schedule);
+
+ /**
+ * @dev Emitted when a {defaultAdmin} transfer is started, setting `newAdmin` as the next
+ * address to become the {defaultAdmin} by calling {acceptDefaultAdminTransfer} only after `acceptSchedule`
+ * passes.
+ */
+ event DefaultAdminTransferScheduled(address indexed newAdmin, uint48 acceptSchedule);
+
+ /**
+ * @dev Emitted when a {pendingDefaultAdmin} is reset if it was never accepted, regardless of its schedule.
+ */
+ event DefaultAdminTransferCanceled();
+
+ /**
+ * @dev Emitted when a {defaultAdminDelay} change is started, setting `newDelay` as the next
+ * delay to be applied between default admin transfer after `effectSchedule` has passed.
+ */
+ event DefaultAdminDelayChangeScheduled(uint48 newDelay, uint48 effectSchedule);
+
+ /**
+ * @dev Emitted when a {pendingDefaultAdminDelay} is reset if its schedule didn't pass.
+ */
+ event DefaultAdminDelayChangeCanceled();
+
+ /**
+ * @dev Returns the address of the current `DEFAULT_ADMIN_ROLE` holder.
+ */
+ function defaultAdmin() external view returns (address);
+
+ /**
+ * @dev Returns a tuple of a `newAdmin` and an accept schedule.
+ *
+ * After the `schedule` passes, the `newAdmin` will be able to accept the {defaultAdmin} role
+ * by calling {acceptDefaultAdminTransfer}, completing the role transfer.
+ *
+ * A zero value only in `acceptSchedule` indicates no pending admin transfer.
+ *
+ * NOTE: A zero address `newAdmin` means that {defaultAdmin} is being renounced.
+ */
+ function pendingDefaultAdmin() external view returns (address newAdmin, uint48 acceptSchedule);
+
+ /**
+ * @dev Returns the delay required to schedule the acceptance of a {defaultAdmin} transfer started.
+ *
+ * This delay will be added to the current timestamp when calling {beginDefaultAdminTransfer} to set
+ * the acceptance schedule.
+ *
+ * NOTE: If a delay change has been scheduled, it will take effect as soon as the schedule passes, making this
+ * function returns the new delay. See {changeDefaultAdminDelay}.
+ */
+ function defaultAdminDelay() external view returns (uint48);
+
+ /**
+ * @dev Returns a tuple of `newDelay` and an effect schedule.
+ *
+ * After the `schedule` passes, the `newDelay` will get into effect immediately for every
+ * new {defaultAdmin} transfer started with {beginDefaultAdminTransfer}.
+ *
+ * A zero value only in `effectSchedule` indicates no pending delay change.
+ *
+ * NOTE: A zero value only for `newDelay` means that the next {defaultAdminDelay}
+ * will be zero after the effect schedule.
+ */
+ function pendingDefaultAdminDelay() external view returns (uint48 newDelay, uint48 effectSchedule);
+
+ /**
+ * @dev Starts a {defaultAdmin} transfer by setting a {pendingDefaultAdmin} scheduled for acceptance
+ * after the current timestamp plus a {defaultAdminDelay}.
+ *
+ * Requirements:
+ *
+ * - Only can be called by the current {defaultAdmin}.
+ *
+ * Emits a DefaultAdminRoleChangeStarted event.
+ */
+ function beginDefaultAdminTransfer(address newAdmin) external;
+
+ /**
+ * @dev Cancels a {defaultAdmin} transfer previously started with {beginDefaultAdminTransfer}.
+ *
+ * A {pendingDefaultAdmin} not yet accepted can also be cancelled with this function.
+ *
+ * Requirements:
+ *
+ * - Only can be called by the current {defaultAdmin}.
+ *
+ * May emit a DefaultAdminTransferCanceled event.
+ */
+ function cancelDefaultAdminTransfer() external;
+
+ /**
+ * @dev Completes a {defaultAdmin} transfer previously started with {beginDefaultAdminTransfer}.
+ *
+ * After calling the function:
+ *
+ * - `DEFAULT_ADMIN_ROLE` should be granted to the caller.
+ * - `DEFAULT_ADMIN_ROLE` should be revoked from the previous holder.
+ * - {pendingDefaultAdmin} should be reset to zero values.
+ *
+ * Requirements:
+ *
+ * - Only can be called by the {pendingDefaultAdmin}'s `newAdmin`.
+ * - The {pendingDefaultAdmin}'s `acceptSchedule` should've passed.
+ */
+ function acceptDefaultAdminTransfer() external;
+
+ /**
+ * @dev Initiates a {defaultAdminDelay} update by setting a {pendingDefaultAdminDelay} scheduled for getting
+ * into effect after the current timestamp plus a {defaultAdminDelay}.
+ *
+ * This function guarantees that any call to {beginDefaultAdminTransfer} done between the timestamp this
+ * method is called and the {pendingDefaultAdminDelay} effect schedule will use the current {defaultAdminDelay}
+ * set before calling.
+ *
+ * The {pendingDefaultAdminDelay}'s effect schedule is defined in a way that waiting until the schedule and then
+ * calling {beginDefaultAdminTransfer} with the new delay will take at least the same as another {defaultAdmin}
+ * complete transfer (including acceptance).
+ *
+ * The schedule is designed for two scenarios:
+ *
+ * - When the delay is changed for a larger one the schedule is `block.timestamp + newDelay` capped by
+ * {defaultAdminDelayIncreaseWait}.
+ * - When the delay is changed for a shorter one, the schedule is `block.timestamp + (current delay - new delay)`.
+ *
+ * A {pendingDefaultAdminDelay} that never got into effect will be canceled in favor of a new scheduled change.
+ *
+ * Requirements:
+ *
+ * - Only can be called by the current {defaultAdmin}.
+ *
+ * Emits a DefaultAdminDelayChangeScheduled event and may emit a DefaultAdminDelayChangeCanceled event.
+ */
+ function changeDefaultAdminDelay(uint48 newDelay) external;
+
+ /**
+ * @dev Cancels a scheduled {defaultAdminDelay} change.
+ *
+ * Requirements:
+ *
+ * - Only can be called by the current {defaultAdmin}.
+ *
+ * May emit a DefaultAdminDelayChangeCanceled event.
+ */
+ function rollbackDefaultAdminDelay() external;
+
+ /**
+ * @dev Maximum time in seconds for an increase to {defaultAdminDelay} (that is scheduled using {changeDefaultAdminDelay})
+ * to take effect. Default to 5 days.
+ *
+ * When the {defaultAdminDelay} is scheduled to be increased, it goes into effect after the new delay has passed with
+ * the purpose of giving enough time for reverting any accidental change (i.e. using milliseconds instead of seconds)
+ * that may lock the contract. However, to avoid excessive schedules, the wait is capped by this function and it can
+ * be overrode for a custom {defaultAdminDelay} increase scheduling.
+ *
+ * IMPORTANT: Make sure to add a reasonable amount of time while overriding this value, otherwise,
+ * there's a risk of setting a high new delay that goes into effect almost immediately without the
+ * possibility of human intervention in the case of an input error (eg. set milliseconds instead of seconds).
+ */
+ function defaultAdminDelayIncreaseWait() external view returns (uint48);
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/extensions/IAccessControlEnumerable.sol b/con/lib/openzeppelin-contracts/contracts/access/extensions/IAccessControlEnumerable.sol
new file mode 100644
index 000000000..90371fa91
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/extensions/IAccessControlEnumerable.sol
@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/extensions/IAccessControlEnumerable.sol)
+
+pragma solidity >=0.8.4;
+
+import {IAccessControl} from "../IAccessControl.sol";
+
+/**
+ * @dev External interface of AccessControlEnumerable declared to support ERC-165 detection.
+ */
+interface IAccessControlEnumerable is IAccessControl {
+ /**
+ * @dev Returns one of the accounts that have `role`. `index` must be a
+ * value between 0 and {getRoleMemberCount}, non-inclusive.
+ *
+ * Role bearers are not sorted in any particular way, and their ordering may
+ * change at any point.
+ *
+ * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
+ * you perform all queries on the same block. See the following
+ * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
+ * for more information.
+ */
+ function getRoleMember(bytes32 role, uint256 index) external view returns (address);
+
+ /**
+ * @dev Returns the number of accounts that have `role`. Can be used
+ * together with {getRoleMember} to enumerate all bearers of a role.
+ */
+ function getRoleMemberCount(bytes32 role) external view returns (uint256);
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/manager/AccessManaged.sol b/con/lib/openzeppelin-contracts/contracts/access/manager/AccessManaged.sol
new file mode 100644
index 000000000..382a3086b
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/manager/AccessManaged.sol
@@ -0,0 +1,112 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/AccessManaged.sol)
+
+pragma solidity ^0.8.20;
+
+import {AuthorityUtils} from "./AuthorityUtils.sol";
+import {IAccessManager} from "./IAccessManager.sol";
+import {IAccessManaged} from "./IAccessManaged.sol";
+import {Context} from "../../utils/Context.sol";
+
+/**
+ * @dev This contract module makes available a {restricted} modifier. Functions decorated with this modifier will be
+ * permissioned according to an "authority": a contract like {AccessManager} that follows the {IAuthority} interface,
+ * implementing a policy that allows certain callers to access certain functions.
+ *
+ * IMPORTANT: The `restricted` modifier should never be used on `internal` functions, judiciously used in `public`
+ * functions, and ideally only used in `external` functions. See {restricted}.
+ */
+abstract contract AccessManaged is Context, IAccessManaged {
+ address private _authority;
+
+ bool private _consumingSchedule;
+
+ /**
+ * @dev Initializes the contract connected to an initial authority.
+ */
+ constructor(address initialAuthority) {
+ _setAuthority(initialAuthority);
+ }
+
+ /**
+ * @dev Restricts access to a function as defined by the connected Authority for this contract and the
+ * caller and selector of the function that entered the contract.
+ *
+ * [IMPORTANT]
+ * ====
+ * In general, this modifier should only be used on `external` functions. It is okay to use it on `public`
+ * functions that are used as external entry points and are not called internally. Unless you know what you're
+ * doing, it should never be used on `internal` functions. Failure to follow these rules can have critical security
+ * implications! This is because the permissions are determined by the function that entered the contract, i.e. the
+ * function at the bottom of the call stack, and not the function where the modifier is visible in the source code.
+ * ====
+ *
+ * [WARNING]
+ * ====
+ * Avoid adding this modifier to the https://docs.soliditylang.org/en/v0.8.20/contracts.html#receive-ether-function[`receive()`]
+ * function or the https://docs.soliditylang.org/en/v0.8.20/contracts.html#fallback-function[`fallback()`]. These
+ * functions are the only execution paths where a function selector cannot be unambiguously determined from the calldata
+ * since the selector defaults to `0x00000000` in the `receive()` function and similarly in the `fallback()` function
+ * if no calldata is provided. (See {_checkCanCall}).
+ *
+ * The `receive()` function will always panic whereas the `fallback()` may panic depending on the calldata length.
+ * ====
+ */
+ modifier restricted() {
+ _checkCanCall(_msgSender(), _msgData());
+ _;
+ }
+
+ /// @inheritdoc IAccessManaged
+ function authority() public view virtual returns (address) {
+ return _authority;
+ }
+
+ /// @inheritdoc IAccessManaged
+ function setAuthority(address newAuthority) public virtual {
+ address caller = _msgSender();
+ if (caller != authority()) {
+ revert AccessManagedUnauthorized(caller);
+ }
+ if (newAuthority.code.length == 0) {
+ revert AccessManagedInvalidAuthority(newAuthority);
+ }
+ _setAuthority(newAuthority);
+ }
+
+ /// @inheritdoc IAccessManaged
+ function isConsumingScheduledOp() public view returns (bytes4) {
+ return _consumingSchedule ? this.isConsumingScheduledOp.selector : bytes4(0);
+ }
+
+ /**
+ * @dev Transfers control to a new authority. Internal function with no access restriction. Allows bypassing the
+ * permissions set by the current authority.
+ */
+ function _setAuthority(address newAuthority) internal virtual {
+ _authority = newAuthority;
+ emit AuthorityUpdated(newAuthority);
+ }
+
+ /**
+ * @dev Reverts if the caller is not allowed to call the function identified by a selector. Panics if the calldata
+ * is less than 4 bytes long.
+ */
+ function _checkCanCall(address caller, bytes calldata data) internal virtual {
+ (bool immediate, uint32 delay) = AuthorityUtils.canCallWithDelay(
+ authority(),
+ caller,
+ address(this),
+ bytes4(data[0:4])
+ );
+ if (!immediate) {
+ if (delay > 0) {
+ _consumingSchedule = true;
+ IAccessManager(authority()).consumeScheduledOp(caller, data);
+ _consumingSchedule = false;
+ } else {
+ revert AccessManagedUnauthorized(caller);
+ }
+ }
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/manager/AccessManager.sol b/con/lib/openzeppelin-contracts/contracts/access/manager/AccessManager.sol
new file mode 100644
index 000000000..051080554
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/manager/AccessManager.sol
@@ -0,0 +1,740 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.1.0) (access/manager/AccessManager.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAccessManager} from "./IAccessManager.sol";
+import {IAccessManaged} from "./IAccessManaged.sol";
+import {Address} from "../../utils/Address.sol";
+import {Context} from "../../utils/Context.sol";
+import {Multicall} from "../../utils/Multicall.sol";
+import {Math} from "../../utils/math/Math.sol";
+import {Time} from "../../utils/types/Time.sol";
+
+/**
+ * @dev AccessManager is a central contract to store the permissions of a system.
+ *
+ * A smart contract under the control of an AccessManager instance is known as a target, and will inherit from the
+ * {AccessManaged} contract, be connected to this contract as its manager and implement the {AccessManaged-restricted}
+ * modifier on a set of functions selected to be permissioned. Note that any function without this setup won't be
+ * effectively restricted.
+ *
+ * The restriction rules for such functions are defined in terms of "roles" identified by an `uint64` and scoped
+ * by target (`address`) and function selectors (`bytes4`). These roles are stored in this contract and can be
+ * configured by admins (`ADMIN_ROLE` members) after a delay (see {getTargetAdminDelay}).
+ *
+ * For each target contract, admins can configure the following without any delay:
+ *
+ * * The target's {AccessManaged-authority} via {updateAuthority}.
+ * * Close or open a target via {setTargetClosed} keeping the permissions intact.
+ * * The roles that are allowed (or disallowed) to call a given function (identified by its selector) through {setTargetFunctionRole}.
+ *
+ * By default every address is member of the `PUBLIC_ROLE` and every target function is restricted to the `ADMIN_ROLE` until configured otherwise.
+ * Additionally, each role has the following configuration options restricted to this manager's admins:
+ *
+ * * A role's admin role via {setRoleAdmin} who can grant or revoke roles.
+ * * A role's guardian role via {setRoleGuardian} who's allowed to cancel operations.
+ * * A delay in which a role takes effect after being granted through {setGrantDelay}.
+ * * A delay of any target's admin action via {setTargetAdminDelay}.
+ * * A role label for discoverability purposes with {labelRole}.
+ *
+ * Any account can be added and removed into any number of these roles by using the {grantRole} and {revokeRole} functions
+ * restricted to each role's admin (see {getRoleAdmin}).
+ *
+ * Since all the permissions of the managed system can be modified by the admins of this instance, it is expected that
+ * they will be highly secured (e.g., a multisig or a well-configured DAO).
+ *
+ * NOTE: This contract implements a form of the {IAuthority} interface, but {canCall} has additional return data so it
+ * doesn't inherit `IAuthority`. It is however compatible with the `IAuthority` interface since the first 32 bytes of
+ * the return data are a boolean as expected by that interface.
+ *
+ * NOTE: Systems that implement other access control mechanisms (for example using {Ownable}) can be paired with an
+ * {AccessManager} by transferring permissions (ownership in the case of {Ownable}) directly to the {AccessManager}.
+ * Users will be able to interact with these contracts through the {execute} function, following the access rules
+ * registered in the {AccessManager}. Keep in mind that in that context, the msg.sender seen by restricted functions
+ * will be {AccessManager} itself.
+ *
+ * WARNING: When granting permissions over an {Ownable} or {AccessControl} contract to an {AccessManager}, be very
+ * mindful of the danger associated with functions such as {Ownable-renounceOwnership} or
+ * {AccessControl-renounceRole}.
+ */
+contract AccessManager is Context, Multicall, IAccessManager {
+ using Time for *;
+
+ // Structure that stores the details for a target contract.
+ struct TargetConfig {
+ mapping(bytes4 selector => uint64 roleId) allowedRoles;
+ Time.Delay adminDelay;
+ bool closed;
+ }
+
+ // Structure that stores the details for a role/account pair. This structures fit into a single slot.
+ struct Access {
+ // Timepoint at which the user gets the permission.
+ // If this is either 0 or in the future, then the role permission is not available.
+ uint48 since;
+ // Delay for execution. Only applies to restricted() / execute() calls.
+ Time.Delay delay;
+ }
+
+ // Structure that stores the details of a role.
+ struct Role {
+ // Members of the role.
+ mapping(address user => Access access) members;
+ // Admin who can grant or revoke permissions.
+ uint64 admin;
+ // Guardian who can cancel operations targeting functions that need this role.
+ uint64 guardian;
+ // Delay in which the role takes effect after being granted.
+ Time.Delay grantDelay;
+ }
+
+ // Structure that stores the details for a scheduled operation. This structure fits into a single slot.
+ struct Schedule {
+ // Moment at which the operation can be executed.
+ uint48 timepoint;
+ // Operation nonce to allow third-party contracts to identify the operation.
+ uint32 nonce;
+ }
+
+ /**
+ * @dev The identifier of the admin role. Required to perform most configuration operations including
+ * other roles' management and target restrictions.
+ */
+ uint64 public constant ADMIN_ROLE = type(uint64).min; // 0
+
+ /**
+ * @dev The identifier of the public role. Automatically granted to all addresses with no delay.
+ */
+ uint64 public constant PUBLIC_ROLE = type(uint64).max; // 2**64-1
+
+ mapping(address target => TargetConfig mode) private _targets;
+ mapping(uint64 roleId => Role) private _roles;
+ mapping(bytes32 operationId => Schedule) private _schedules;
+
+ // Used to identify operations that are currently being executed via {execute}.
+ // This should be transient storage when supported by the EVM.
+ bytes32 private _executionId;
+
+ /**
+ * @dev Check that the caller is authorized to perform the operation.
+ * See {AccessManager} description for a detailed breakdown of the authorization logic.
+ */
+ modifier onlyAuthorized() {
+ _checkAuthorized();
+ _;
+ }
+
+ constructor(address initialAdmin) {
+ if (initialAdmin == address(0)) {
+ revert AccessManagerInvalidInitialAdmin(address(0));
+ }
+
+ // admin is active immediately and without any execution delay.
+ _grantRole(ADMIN_ROLE, initialAdmin, 0, 0);
+ }
+
+ // =================================================== GETTERS ====================================================
+ /// @inheritdoc IAccessManager
+ function canCall(
+ address caller,
+ address target,
+ bytes4 selector
+ ) public view virtual returns (bool immediate, uint32 delay) {
+ if (isTargetClosed(target)) {
+ return (false, 0);
+ } else if (caller == address(this)) {
+ // Caller is AccessManager, this means the call was sent through {execute} and it already checked
+ // permissions. We verify that the call "identifier", which is set during {execute}, is correct.
+ return (_isExecuting(target, selector), 0);
+ } else {
+ uint64 roleId = getTargetFunctionRole(target, selector);
+ (bool isMember, uint32 currentDelay) = hasRole(roleId, caller);
+ return isMember ? (currentDelay == 0, currentDelay) : (false, 0);
+ }
+ }
+
+ /// @inheritdoc IAccessManager
+ function expiration() public view virtual returns (uint32) {
+ return 1 weeks;
+ }
+
+ /// @inheritdoc IAccessManager
+ function minSetback() public view virtual returns (uint32) {
+ return 5 days;
+ }
+
+ /// @inheritdoc IAccessManager
+ function isTargetClosed(address target) public view virtual returns (bool) {
+ return _targets[target].closed;
+ }
+
+ /// @inheritdoc IAccessManager
+ function getTargetFunctionRole(address target, bytes4 selector) public view virtual returns (uint64) {
+ return _targets[target].allowedRoles[selector];
+ }
+
+ /// @inheritdoc IAccessManager
+ function getTargetAdminDelay(address target) public view virtual returns (uint32) {
+ return _targets[target].adminDelay.get();
+ }
+
+ /// @inheritdoc IAccessManager
+ function getRoleAdmin(uint64 roleId) public view virtual returns (uint64) {
+ return _roles[roleId].admin;
+ }
+
+ /// @inheritdoc IAccessManager
+ function getRoleGuardian(uint64 roleId) public view virtual returns (uint64) {
+ return _roles[roleId].guardian;
+ }
+
+ /// @inheritdoc IAccessManager
+ function getRoleGrantDelay(uint64 roleId) public view virtual returns (uint32) {
+ return _roles[roleId].grantDelay.get();
+ }
+
+ /// @inheritdoc IAccessManager
+ function getAccess(
+ uint64 roleId,
+ address account
+ ) public view virtual returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect) {
+ Access storage access = _roles[roleId].members[account];
+
+ since = access.since;
+ (currentDelay, pendingDelay, effect) = access.delay.getFull();
+
+ return (since, currentDelay, pendingDelay, effect);
+ }
+
+ /// @inheritdoc IAccessManager
+ function hasRole(
+ uint64 roleId,
+ address account
+ ) public view virtual returns (bool isMember, uint32 executionDelay) {
+ if (roleId == PUBLIC_ROLE) {
+ return (true, 0);
+ } else {
+ (uint48 hasRoleSince, uint32 currentDelay, , ) = getAccess(roleId, account);
+ return (hasRoleSince != 0 && hasRoleSince <= Time.timestamp(), currentDelay);
+ }
+ }
+
+ // =============================================== ROLE MANAGEMENT ===============================================
+ /// @inheritdoc IAccessManager
+ function labelRole(uint64 roleId, string calldata label) public virtual onlyAuthorized {
+ if (roleId == ADMIN_ROLE || roleId == PUBLIC_ROLE) {
+ revert AccessManagerLockedRole(roleId);
+ }
+ emit RoleLabel(roleId, label);
+ }
+
+ /// @inheritdoc IAccessManager
+ function grantRole(uint64 roleId, address account, uint32 executionDelay) public virtual onlyAuthorized {
+ _grantRole(roleId, account, getRoleGrantDelay(roleId), executionDelay);
+ }
+
+ /// @inheritdoc IAccessManager
+ function revokeRole(uint64 roleId, address account) public virtual onlyAuthorized {
+ _revokeRole(roleId, account);
+ }
+
+ /// @inheritdoc IAccessManager
+ function renounceRole(uint64 roleId, address callerConfirmation) public virtual {
+ if (callerConfirmation != _msgSender()) {
+ revert AccessManagerBadConfirmation();
+ }
+ _revokeRole(roleId, callerConfirmation);
+ }
+
+ /// @inheritdoc IAccessManager
+ function setRoleAdmin(uint64 roleId, uint64 admin) public virtual onlyAuthorized {
+ _setRoleAdmin(roleId, admin);
+ }
+
+ /// @inheritdoc IAccessManager
+ function setRoleGuardian(uint64 roleId, uint64 guardian) public virtual onlyAuthorized {
+ _setRoleGuardian(roleId, guardian);
+ }
+
+ /// @inheritdoc IAccessManager
+ function setGrantDelay(uint64 roleId, uint32 newDelay) public virtual onlyAuthorized {
+ _setGrantDelay(roleId, newDelay);
+ }
+
+ /**
+ * @dev Internal version of {grantRole} without access control. Returns true if the role was newly granted.
+ *
+ * Emits a {RoleGranted} event.
+ */
+ function _grantRole(
+ uint64 roleId,
+ address account,
+ uint32 grantDelay,
+ uint32 executionDelay
+ ) internal virtual returns (bool) {
+ if (roleId == PUBLIC_ROLE) {
+ revert AccessManagerLockedRole(roleId);
+ }
+
+ bool newMember = _roles[roleId].members[account].since == 0;
+ uint48 since;
+
+ if (newMember) {
+ since = Time.timestamp() + grantDelay;
+ _roles[roleId].members[account] = Access({since: since, delay: executionDelay.toDelay()});
+ } else {
+ // No setback here. Value can be reset by doing revoke + grant, effectively allowing the admin to perform
+ // any change to the execution delay within the duration of the role admin delay.
+ (_roles[roleId].members[account].delay, since) = _roles[roleId].members[account].delay.withUpdate(
+ executionDelay,
+ 0
+ );
+ }
+
+ emit RoleGranted(roleId, account, executionDelay, since, newMember);
+ return newMember;
+ }
+
+ /**
+ * @dev Internal version of {revokeRole} without access control. This logic is also used by {renounceRole}.
+ * Returns true if the role was previously granted.
+ *
+ * Emits a {RoleRevoked} event if the account had the role.
+ */
+ function _revokeRole(uint64 roleId, address account) internal virtual returns (bool) {
+ if (roleId == PUBLIC_ROLE) {
+ revert AccessManagerLockedRole(roleId);
+ }
+
+ if (_roles[roleId].members[account].since == 0) {
+ return false;
+ }
+
+ delete _roles[roleId].members[account];
+
+ emit RoleRevoked(roleId, account);
+ return true;
+ }
+
+ /**
+ * @dev Internal version of {setRoleAdmin} without access control.
+ *
+ * Emits a {RoleAdminChanged} event.
+ *
+ * NOTE: Setting the admin role as the `PUBLIC_ROLE` is allowed, but it will effectively allow
+ * anyone to set grant or revoke such role.
+ */
+ function _setRoleAdmin(uint64 roleId, uint64 admin) internal virtual {
+ if (roleId == ADMIN_ROLE || roleId == PUBLIC_ROLE) {
+ revert AccessManagerLockedRole(roleId);
+ }
+
+ _roles[roleId].admin = admin;
+
+ emit RoleAdminChanged(roleId, admin);
+ }
+
+ /**
+ * @dev Internal version of {setRoleGuardian} without access control.
+ *
+ * Emits a {RoleGuardianChanged} event.
+ *
+ * NOTE: Setting the guardian role as the `PUBLIC_ROLE` is allowed, but it will effectively allow
+ * anyone to cancel any scheduled operation for such role.
+ */
+ function _setRoleGuardian(uint64 roleId, uint64 guardian) internal virtual {
+ if (roleId == ADMIN_ROLE || roleId == PUBLIC_ROLE) {
+ revert AccessManagerLockedRole(roleId);
+ }
+
+ _roles[roleId].guardian = guardian;
+
+ emit RoleGuardianChanged(roleId, guardian);
+ }
+
+ /**
+ * @dev Internal version of {setGrantDelay} without access control.
+ *
+ * Emits a {RoleGrantDelayChanged} event.
+ */
+ function _setGrantDelay(uint64 roleId, uint32 newDelay) internal virtual {
+ if (roleId == PUBLIC_ROLE) {
+ revert AccessManagerLockedRole(roleId);
+ }
+
+ uint48 effect;
+ (_roles[roleId].grantDelay, effect) = _roles[roleId].grantDelay.withUpdate(newDelay, minSetback());
+
+ emit RoleGrantDelayChanged(roleId, newDelay, effect);
+ }
+
+ // ============================================= FUNCTION MANAGEMENT ==============================================
+ /// @inheritdoc IAccessManager
+ function setTargetFunctionRole(
+ address target,
+ bytes4[] calldata selectors,
+ uint64 roleId
+ ) public virtual onlyAuthorized {
+ for (uint256 i = 0; i < selectors.length; ++i) {
+ _setTargetFunctionRole(target, selectors[i], roleId);
+ }
+ }
+
+ /**
+ * @dev Internal version of {setTargetFunctionRole} without access control.
+ *
+ * Emits a {TargetFunctionRoleUpdated} event.
+ */
+ function _setTargetFunctionRole(address target, bytes4 selector, uint64 roleId) internal virtual {
+ _targets[target].allowedRoles[selector] = roleId;
+ emit TargetFunctionRoleUpdated(target, selector, roleId);
+ }
+
+ /// @inheritdoc IAccessManager
+ function setTargetAdminDelay(address target, uint32 newDelay) public virtual onlyAuthorized {
+ _setTargetAdminDelay(target, newDelay);
+ }
+
+ /**
+ * @dev Internal version of {setTargetAdminDelay} without access control.
+ *
+ * Emits a {TargetAdminDelayUpdated} event.
+ */
+ function _setTargetAdminDelay(address target, uint32 newDelay) internal virtual {
+ uint48 effect;
+ (_targets[target].adminDelay, effect) = _targets[target].adminDelay.withUpdate(newDelay, minSetback());
+
+ emit TargetAdminDelayUpdated(target, newDelay, effect);
+ }
+
+ // =============================================== MODE MANAGEMENT ================================================
+ /// @inheritdoc IAccessManager
+ function setTargetClosed(address target, bool closed) public virtual onlyAuthorized {
+ _setTargetClosed(target, closed);
+ }
+
+ /**
+ * @dev Set the closed flag for a contract. This is an internal setter with no access restrictions.
+ *
+ * Emits a {TargetClosed} event.
+ */
+ function _setTargetClosed(address target, bool closed) internal virtual {
+ _targets[target].closed = closed;
+ emit TargetClosed(target, closed);
+ }
+
+ // ============================================== DELAYED OPERATIONS ==============================================
+ /// @inheritdoc IAccessManager
+ function getSchedule(bytes32 id) public view virtual returns (uint48) {
+ uint48 timepoint = _schedules[id].timepoint;
+ return _isExpired(timepoint) ? 0 : timepoint;
+ }
+
+ /// @inheritdoc IAccessManager
+ function getNonce(bytes32 id) public view virtual returns (uint32) {
+ return _schedules[id].nonce;
+ }
+
+ /// @inheritdoc IAccessManager
+ function schedule(
+ address target,
+ bytes calldata data,
+ uint48 when
+ ) public virtual returns (bytes32 operationId, uint32 nonce) {
+ address caller = _msgSender();
+
+ // Fetch restrictions that apply to the caller on the targeted function
+ (, uint32 setback) = _canCallExtended(caller, target, data);
+
+ uint48 minWhen = Time.timestamp() + setback;
+
+ // If call with delay is not authorized, or if requested timing is too soon, revert
+ if (setback == 0 || (when > 0 && when < minWhen)) {
+ revert AccessManagerUnauthorizedCall(caller, target, _checkSelector(data));
+ }
+
+ // Reuse variable due to stack too deep
+ when = uint48(Math.max(when, minWhen)); // cast is safe: both inputs are uint48
+
+ // If caller is authorised, schedule operation
+ operationId = hashOperation(caller, target, data);
+
+ _checkNotScheduled(operationId);
+
+ unchecked {
+ // It's not feasible to overflow the nonce in less than 1000 years
+ nonce = _schedules[operationId].nonce + 1;
+ }
+ _schedules[operationId].timepoint = when;
+ _schedules[operationId].nonce = nonce;
+ emit OperationScheduled(operationId, nonce, when, caller, target, data);
+
+ // Using named return values because otherwise we get stack too deep
+ }
+
+ /**
+ * @dev Reverts if the operation is currently scheduled and has not expired.
+ *
+ * NOTE: This function was introduced due to stack too deep errors in schedule.
+ */
+ function _checkNotScheduled(bytes32 operationId) private view {
+ uint48 prevTimepoint = _schedules[operationId].timepoint;
+ if (prevTimepoint != 0 && !_isExpired(prevTimepoint)) {
+ revert AccessManagerAlreadyScheduled(operationId);
+ }
+ }
+
+ /// @inheritdoc IAccessManager
+ // Reentrancy is not an issue because permissions are checked on msg.sender. Additionally,
+ // _consumeScheduledOp guarantees a scheduled operation is only executed once.
+ // slither-disable-next-line reentrancy-no-eth
+ function execute(address target, bytes calldata data) public payable virtual returns (uint32) {
+ address caller = _msgSender();
+
+ // Fetch restrictions that apply to the caller on the targeted function
+ (bool immediate, uint32 setback) = _canCallExtended(caller, target, data);
+
+ // If call is not authorized, revert
+ if (!immediate && setback == 0) {
+ revert AccessManagerUnauthorizedCall(caller, target, _checkSelector(data));
+ }
+
+ bytes32 operationId = hashOperation(caller, target, data);
+ uint32 nonce;
+
+ // If caller is authorised, check operation was scheduled early enough
+ // Consume an available schedule even if there is no currently enforced delay
+ if (setback != 0 || getSchedule(operationId) != 0) {
+ nonce = _consumeScheduledOp(operationId);
+ }
+
+ // Mark the target and selector as authorised
+ bytes32 executionIdBefore = _executionId;
+ _executionId = _hashExecutionId(target, _checkSelector(data));
+
+ // Perform call
+ Address.functionCallWithValue(target, data, msg.value);
+
+ // Reset execute identifier
+ _executionId = executionIdBefore;
+
+ return nonce;
+ }
+
+ /// @inheritdoc IAccessManager
+ function cancel(address caller, address target, bytes calldata data) public virtual returns (uint32) {
+ address msgsender = _msgSender();
+ bytes4 selector = _checkSelector(data);
+
+ bytes32 operationId = hashOperation(caller, target, data);
+ if (_schedules[operationId].timepoint == 0) {
+ revert AccessManagerNotScheduled(operationId);
+ } else if (caller != msgsender) {
+ // calls can only be canceled by the account that scheduled them, a global admin, or by a guardian of the required role.
+ (bool isAdmin, ) = hasRole(ADMIN_ROLE, msgsender);
+ (bool isGuardian, ) = hasRole(getRoleGuardian(getTargetFunctionRole(target, selector)), msgsender);
+ if (!isAdmin && !isGuardian) {
+ revert AccessManagerUnauthorizedCancel(msgsender, caller, target, selector);
+ }
+ }
+
+ delete _schedules[operationId].timepoint; // reset the timepoint, keep the nonce
+ uint32 nonce = _schedules[operationId].nonce;
+ emit OperationCanceled(operationId, nonce);
+
+ return nonce;
+ }
+
+ /// @inheritdoc IAccessManager
+ function consumeScheduledOp(address caller, bytes calldata data) public virtual {
+ address target = _msgSender();
+ if (IAccessManaged(target).isConsumingScheduledOp() != IAccessManaged.isConsumingScheduledOp.selector) {
+ revert AccessManagerUnauthorizedConsume(target);
+ }
+ _consumeScheduledOp(hashOperation(caller, target, data));
+ }
+
+ /**
+ * @dev Internal variant of {consumeScheduledOp} that operates on bytes32 operationId.
+ *
+ * Returns the nonce of the scheduled operation that is consumed.
+ */
+ function _consumeScheduledOp(bytes32 operationId) internal virtual returns (uint32) {
+ uint48 timepoint = _schedules[operationId].timepoint;
+ uint32 nonce = _schedules[operationId].nonce;
+
+ if (timepoint == 0) {
+ revert AccessManagerNotScheduled(operationId);
+ } else if (timepoint > Time.timestamp()) {
+ revert AccessManagerNotReady(operationId);
+ } else if (_isExpired(timepoint)) {
+ revert AccessManagerExpired(operationId);
+ }
+
+ delete _schedules[operationId].timepoint; // reset the timepoint, keep the nonce
+ emit OperationExecuted(operationId, nonce);
+
+ return nonce;
+ }
+
+ /// @inheritdoc IAccessManager
+ function hashOperation(address caller, address target, bytes calldata data) public view virtual returns (bytes32) {
+ return keccak256(abi.encode(caller, target, data));
+ }
+
+ // ==================================================== OTHERS ====================================================
+ /// @inheritdoc IAccessManager
+ function updateAuthority(address target, address newAuthority) public virtual onlyAuthorized {
+ IAccessManaged(target).setAuthority(newAuthority);
+ }
+
+ // ================================================= ADMIN LOGIC ==================================================
+ /**
+ * @dev Check if the current call is authorized according to admin and roles logic.
+ *
+ * WARNING: Carefully review the considerations of {AccessManaged-restricted} since they apply to this modifier.
+ */
+ function _checkAuthorized() private {
+ address caller = _msgSender();
+ (bool immediate, uint32 delay) = _canCallSelf(caller, _msgData());
+ if (!immediate) {
+ if (delay == 0) {
+ (, uint64 requiredRole, ) = _getAdminRestrictions(_msgData());
+ revert AccessManagerUnauthorizedAccount(caller, requiredRole);
+ } else {
+ _consumeScheduledOp(hashOperation(caller, address(this), _msgData()));
+ }
+ }
+ }
+
+ /**
+ * @dev Get the admin restrictions of a given function call based on the function and arguments involved.
+ *
+ * Returns:
+ * - bool restricted: does this data match a restricted operation
+ * - uint64: which role is this operation restricted to
+ * - uint32: minimum delay to enforce for that operation (max between operation's delay and admin's execution delay)
+ */
+ function _getAdminRestrictions(
+ bytes calldata data
+ ) private view returns (bool adminRestricted, uint64 roleAdminId, uint32 executionDelay) {
+ if (data.length < 4) {
+ return (false, 0, 0);
+ }
+
+ bytes4 selector = _checkSelector(data);
+
+ // Restricted to ADMIN with no delay beside any execution delay the caller may have
+ if (
+ selector == this.labelRole.selector ||
+ selector == this.setRoleAdmin.selector ||
+ selector == this.setRoleGuardian.selector ||
+ selector == this.setGrantDelay.selector ||
+ selector == this.setTargetAdminDelay.selector
+ ) {
+ return (true, ADMIN_ROLE, 0);
+ }
+
+ // Restricted to ADMIN with the admin delay corresponding to the target
+ if (
+ selector == this.updateAuthority.selector ||
+ selector == this.setTargetClosed.selector ||
+ selector == this.setTargetFunctionRole.selector
+ ) {
+ // First argument is a target.
+ address target = abi.decode(data[0x04:0x24], (address));
+ uint32 delay = getTargetAdminDelay(target);
+ return (true, ADMIN_ROLE, delay);
+ }
+
+ // Restricted to that role's admin with no delay beside any execution delay the caller may have.
+ if (selector == this.grantRole.selector || selector == this.revokeRole.selector) {
+ // First argument is a roleId.
+ uint64 roleId = abi.decode(data[0x04:0x24], (uint64));
+ return (true, getRoleAdmin(roleId), 0);
+ }
+
+ return (false, getTargetFunctionRole(address(this), selector), 0);
+ }
+
+ // =================================================== HELPERS ====================================================
+ /**
+ * @dev An extended version of {canCall} for internal usage that checks {_canCallSelf}
+ * when the target is this contract.
+ *
+ * Returns:
+ * - bool immediate: whether the operation can be executed immediately (with no delay)
+ * - uint32 delay: the execution delay
+ */
+ function _canCallExtended(
+ address caller,
+ address target,
+ bytes calldata data
+ ) private view returns (bool immediate, uint32 delay) {
+ if (target == address(this)) {
+ return _canCallSelf(caller, data);
+ } else {
+ return data.length < 4 ? (false, 0) : canCall(caller, target, _checkSelector(data));
+ }
+ }
+
+ /**
+ * @dev A version of {canCall} that checks for restrictions in this contract.
+ */
+ function _canCallSelf(address caller, bytes calldata data) private view returns (bool immediate, uint32 delay) {
+ if (data.length < 4) {
+ return (false, 0);
+ }
+
+ if (caller == address(this)) {
+ // Caller is AccessManager, this means the call was sent through {execute} and it already checked
+ // permissions. We verify that the call "identifier", which is set during {execute}, is correct.
+ return (_isExecuting(address(this), _checkSelector(data)), 0);
+ }
+
+ (bool adminRestricted, uint64 roleId, uint32 operationDelay) = _getAdminRestrictions(data);
+
+ // isTargetClosed apply to non-admin-restricted function
+ if (!adminRestricted && isTargetClosed(address(this))) {
+ return (false, 0);
+ }
+
+ (bool inRole, uint32 executionDelay) = hasRole(roleId, caller);
+ if (!inRole) {
+ return (false, 0);
+ }
+
+ // downcast is safe because both options are uint32
+ delay = uint32(Math.max(operationDelay, executionDelay));
+ return (delay == 0, delay);
+ }
+
+ /**
+ * @dev Returns true if a call with `target` and `selector` is being executed via {executed}.
+ */
+ function _isExecuting(address target, bytes4 selector) private view returns (bool) {
+ return _executionId == _hashExecutionId(target, selector);
+ }
+
+ /**
+ * @dev Returns true if a schedule timepoint is past its expiration deadline.
+ */
+ function _isExpired(uint48 timepoint) private view returns (bool) {
+ return timepoint + expiration() <= Time.timestamp();
+ }
+
+ /**
+ * @dev Extracts the selector from calldata. Panics if data is not at least 4 bytes
+ */
+ function _checkSelector(bytes calldata data) private pure returns (bytes4) {
+ return bytes4(data[0:4]);
+ }
+
+ /**
+ * @dev Hashing function for execute protection
+ */
+ function _hashExecutionId(address target, bytes4 selector) private pure returns (bytes32) {
+ return keccak256(abi.encode(target, selector));
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/manager/AuthorityUtils.sol b/con/lib/openzeppelin-contracts/contracts/access/manager/AuthorityUtils.sol
new file mode 100644
index 000000000..8b0470968
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/manager/AuthorityUtils.sol
@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.3.0) (access/manager/AuthorityUtils.sol)
+
+pragma solidity ^0.8.20;
+
+import {IAuthority} from "./IAuthority.sol";
+
+library AuthorityUtils {
+ /**
+ * @dev Since `AccessManager` implements an extended IAuthority interface, invoking `canCall` with backwards compatibility
+ * for the preexisting `IAuthority` interface requires special care to avoid reverting on insufficient return data.
+ * This helper function takes care of invoking `canCall` in a backwards compatible way without reverting.
+ */
+ function canCallWithDelay(
+ address authority,
+ address caller,
+ address target,
+ bytes4 selector
+ ) internal view returns (bool immediate, uint32 delay) {
+ 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)))
+ }
+ }
+ }
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/manager/IAccessManaged.sol b/con/lib/openzeppelin-contracts/contracts/access/manager/IAccessManaged.sol
new file mode 100644
index 000000000..c93c71195
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/manager/IAccessManaged.sol
@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManaged.sol)
+
+pragma solidity >=0.8.4;
+
+interface IAccessManaged {
+ /**
+ * @dev Authority that manages this contract was updated.
+ */
+ event AuthorityUpdated(address authority);
+
+ error AccessManagedUnauthorized(address caller);
+ error AccessManagedRequiredDelay(address caller, uint32 delay);
+ error AccessManagedInvalidAuthority(address authority);
+
+ /**
+ * @dev Returns the current authority.
+ */
+ function authority() external view returns (address);
+
+ /**
+ * @dev Transfers control to a new authority. The caller must be the current authority.
+ */
+ function setAuthority(address) external;
+
+ /**
+ * @dev Returns true only in the context of a delayed restricted call, at the moment that the scheduled operation is
+ * being consumed. Prevents denial of service for delayed restricted calls in the case that the contract performs
+ * attacker controlled calls.
+ */
+ function isConsumingScheduledOp() external view returns (bytes4);
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/manager/IAccessManager.sol b/con/lib/openzeppelin-contracts/contracts/access/manager/IAccessManager.sol
new file mode 100644
index 000000000..925be9074
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/manager/IAccessManager.sol
@@ -0,0 +1,399 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAccessManager.sol)
+
+pragma solidity >=0.8.4;
+
+interface IAccessManager {
+ /**
+ * @dev A delayed operation was scheduled.
+ */
+ event OperationScheduled(
+ bytes32 indexed operationId,
+ uint32 indexed nonce,
+ uint48 schedule,
+ address caller,
+ address target,
+ bytes data
+ );
+
+ /**
+ * @dev A scheduled operation was executed.
+ */
+ event OperationExecuted(bytes32 indexed operationId, uint32 indexed nonce);
+
+ /**
+ * @dev A scheduled operation was canceled.
+ */
+ event OperationCanceled(bytes32 indexed operationId, uint32 indexed nonce);
+
+ /**
+ * @dev Informational labelling for a roleId.
+ */
+ event RoleLabel(uint64 indexed roleId, string label);
+
+ /**
+ * @dev Emitted when `account` is granted `roleId`.
+ *
+ * NOTE: The meaning of the `since` argument depends on the `newMember` argument.
+ * If the role is granted to a new member, the `since` argument indicates when the account becomes a member of the role,
+ * otherwise it indicates the execution delay for this account and roleId is updated.
+ */
+ event RoleGranted(uint64 indexed roleId, address indexed account, uint32 delay, uint48 since, bool newMember);
+
+ /**
+ * @dev Emitted when `account` membership or `roleId` is revoked. Unlike granting, revoking is instantaneous.
+ */
+ event RoleRevoked(uint64 indexed roleId, address indexed account);
+
+ /**
+ * @dev Role acting as admin over a given `roleId` is updated.
+ */
+ event RoleAdminChanged(uint64 indexed roleId, uint64 indexed admin);
+
+ /**
+ * @dev Role acting as guardian over a given `roleId` is updated.
+ */
+ event RoleGuardianChanged(uint64 indexed roleId, uint64 indexed guardian);
+
+ /**
+ * @dev Grant delay for a given `roleId` will be updated to `delay` when `since` is reached.
+ */
+ event RoleGrantDelayChanged(uint64 indexed roleId, uint32 delay, uint48 since);
+
+ /**
+ * @dev Target mode is updated (true = closed, false = open).
+ */
+ event TargetClosed(address indexed target, bool closed);
+
+ /**
+ * @dev Role required to invoke `selector` on `target` is updated to `roleId`.
+ */
+ event TargetFunctionRoleUpdated(address indexed target, bytes4 selector, uint64 indexed roleId);
+
+ /**
+ * @dev Admin delay for a given `target` will be updated to `delay` when `since` is reached.
+ */
+ event TargetAdminDelayUpdated(address indexed target, uint32 delay, uint48 since);
+
+ error AccessManagerAlreadyScheduled(bytes32 operationId);
+ error AccessManagerNotScheduled(bytes32 operationId);
+ error AccessManagerNotReady(bytes32 operationId);
+ error AccessManagerExpired(bytes32 operationId);
+ error AccessManagerLockedRole(uint64 roleId);
+ error AccessManagerBadConfirmation();
+ error AccessManagerUnauthorizedAccount(address msgsender, uint64 roleId);
+ error AccessManagerUnauthorizedCall(address caller, address target, bytes4 selector);
+ error AccessManagerUnauthorizedConsume(address target);
+ error AccessManagerUnauthorizedCancel(address msgsender, address caller, address target, bytes4 selector);
+ error AccessManagerInvalidInitialAdmin(address initialAdmin);
+
+ /**
+ * @dev Check if an address (`caller`) is authorised to call a given function on a given contract directly (with
+ * no restriction). Additionally, it returns the delay needed to perform the call indirectly through the {schedule}
+ * & {execute} workflow.
+ *
+ * This function is usually called by the targeted contract to control immediate execution of restricted functions.
+ * Therefore we only return true if the call can be performed without any delay. If the call is subject to a
+ * previously set delay (not zero), then the function should return false and the caller should schedule the operation
+ * for future execution.
+ *
+ * If `allowed` is true, the delay can be disregarded and the operation can be immediately executed, otherwise
+ * the operation can be executed if and only if delay is greater than 0.
+ *
+ * NOTE: The IAuthority interface does not include the `uint32` delay. This is an extension of that interface that
+ * is backward compatible. Some contracts may thus ignore the second return argument. In that case they will fail
+ * to identify the indirect workflow, and will consider calls that require a delay to be forbidden.
+ *
+ * NOTE: This function does not report the permissions of the admin functions in the manager itself. These are defined by the
+ * {AccessManager} documentation.
+ */
+ function canCall(
+ address caller,
+ address target,
+ bytes4 selector
+ ) external view returns (bool allowed, uint32 delay);
+
+ /**
+ * @dev Expiration delay for scheduled proposals. Defaults to 1 week.
+ *
+ * IMPORTANT: Avoid overriding the expiration with 0. Otherwise every contract proposal will be expired immediately,
+ * disabling any scheduling usage.
+ */
+ function expiration() external view returns (uint32);
+
+ /**
+ * @dev Minimum setback for all delay updates, with the exception of execution delays. It
+ * can be increased without setback (and reset via {revokeRole} in the case event of an
+ * accidental increase). Defaults to 5 days.
+ */
+ function minSetback() external view returns (uint32);
+
+ /**
+ * @dev Get whether the contract is closed disabling any access. Otherwise role permissions are applied.
+ *
+ * NOTE: When the manager itself is closed, admin functions are still accessible to avoid locking the contract.
+ */
+ function isTargetClosed(address target) external view returns (bool);
+
+ /**
+ * @dev Get the role required to call a function.
+ */
+ function getTargetFunctionRole(address target, bytes4 selector) external view returns (uint64);
+
+ /**
+ * @dev Get the admin delay for a target contract. Changes to contract configuration are subject to this delay.
+ */
+ function getTargetAdminDelay(address target) external view returns (uint32);
+
+ /**
+ * @dev Get the id of the role that acts as an admin for the given role.
+ *
+ * The admin permission is required to grant the role, revoke the role and update the execution delay to execute
+ * an operation that is restricted to this role.
+ */
+ function getRoleAdmin(uint64 roleId) external view returns (uint64);
+
+ /**
+ * @dev Get the role that acts as a guardian for a given role.
+ *
+ * The guardian permission allows canceling operations that have been scheduled under the role.
+ */
+ function getRoleGuardian(uint64 roleId) external view returns (uint64);
+
+ /**
+ * @dev Get the role current grant delay.
+ *
+ * Its value may change at any point without an event emitted following a call to {setGrantDelay}.
+ * Changes to this value, including effect timepoint are notified in advance by the {RoleGrantDelayChanged} event.
+ */
+ function getRoleGrantDelay(uint64 roleId) external view returns (uint32);
+
+ /**
+ * @dev Get the access details for a given account for a given role. These details include the timepoint at which
+ * membership becomes active, and the delay applied to all operation by this user that requires this permission
+ * level.
+ *
+ * Returns:
+ * [0] Timestamp at which the account membership becomes valid. 0 means role is not granted.
+ * [1] Current execution delay for the account.
+ * [2] Pending execution delay for the account.
+ * [3] Timestamp at which the pending execution delay will become active. 0 means no delay update is scheduled.
+ */
+ function getAccess(
+ uint64 roleId,
+ address account
+ ) external view returns (uint48 since, uint32 currentDelay, uint32 pendingDelay, uint48 effect);
+
+ /**
+ * @dev Check if a given account currently has the permission level corresponding to a given role. Note that this
+ * permission might be associated with an execution delay. {getAccess} can provide more details.
+ */
+ function hasRole(uint64 roleId, address account) external view returns (bool isMember, uint32 executionDelay);
+
+ /**
+ * @dev Give a label to a role, for improved role discoverability by UIs.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {RoleLabel} event.
+ */
+ function labelRole(uint64 roleId, string calldata label) external;
+
+ /**
+ * @dev Add `account` to `roleId`, or change its execution delay.
+ *
+ * This gives the account the authorization to call any function that is restricted to this role. An optional
+ * execution delay (in seconds) can be set. If that delay is non 0, the user is required to schedule any operation
+ * that is restricted to members of this role. The user will only be able to execute the operation after the delay has
+ * passed, before it has expired. During this period, admin and guardians can cancel the operation (see {cancel}).
+ *
+ * If the account has already been granted this role, the execution delay will be updated. This update is not
+ * immediate and follows the delay rules. For example, if a user currently has a delay of 3 hours, and this is
+ * called to reduce that delay to 1 hour, the new delay will take some time to take effect, enforcing that any
+ * operation executed in the 3 hours that follows this update was indeed scheduled before this update.
+ *
+ * Requirements:
+ *
+ * - the caller must be an admin for the role (see {getRoleAdmin})
+ * - granted role must not be the `PUBLIC_ROLE`
+ *
+ * Emits a {RoleGranted} event.
+ */
+ function grantRole(uint64 roleId, address account, uint32 executionDelay) external;
+
+ /**
+ * @dev Remove an account from a role, with immediate effect. If the account does not have the role, this call has
+ * no effect.
+ *
+ * Requirements:
+ *
+ * - the caller must be an admin for the role (see {getRoleAdmin})
+ * - revoked role must not be the `PUBLIC_ROLE`
+ *
+ * Emits a {RoleRevoked} event if the account had the role.
+ */
+ function revokeRole(uint64 roleId, address account) external;
+
+ /**
+ * @dev Renounce role permissions for the calling account with immediate effect. If the sender is not in
+ * the role this call has no effect.
+ *
+ * Requirements:
+ *
+ * - the caller must be `callerConfirmation`.
+ *
+ * Emits a {RoleRevoked} event if the account had the role.
+ */
+ function renounceRole(uint64 roleId, address callerConfirmation) external;
+
+ /**
+ * @dev Change admin role for a given role.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {RoleAdminChanged} event
+ */
+ function setRoleAdmin(uint64 roleId, uint64 admin) external;
+
+ /**
+ * @dev Change guardian role for a given role.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {RoleGuardianChanged} event
+ */
+ function setRoleGuardian(uint64 roleId, uint64 guardian) external;
+
+ /**
+ * @dev Update the delay for granting a `roleId`.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {RoleGrantDelayChanged} event.
+ */
+ function setGrantDelay(uint64 roleId, uint32 newDelay) external;
+
+ /**
+ * @dev Set the role required to call functions identified by the `selectors` in the `target` contract.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {TargetFunctionRoleUpdated} event per selector.
+ */
+ function setTargetFunctionRole(address target, bytes4[] calldata selectors, uint64 roleId) external;
+
+ /**
+ * @dev Set the delay for changing the configuration of a given target contract.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {TargetAdminDelayUpdated} event.
+ */
+ function setTargetAdminDelay(address target, uint32 newDelay) external;
+
+ /**
+ * @dev Set the closed flag for a contract.
+ *
+ * Closing the manager itself won't disable access to admin methods to avoid locking the contract.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ *
+ * Emits a {TargetClosed} event.
+ */
+ function setTargetClosed(address target, bool closed) external;
+
+ /**
+ * @dev Return the timepoint at which a scheduled operation will be ready for execution. This returns 0 if the
+ * operation is not yet scheduled, has expired, was executed, or was canceled.
+ */
+ function getSchedule(bytes32 id) external view returns (uint48);
+
+ /**
+ * @dev Return the nonce for the latest scheduled operation with a given id. Returns 0 if the operation has never
+ * been scheduled.
+ */
+ function getNonce(bytes32 id) external view returns (uint32);
+
+ /**
+ * @dev Schedule a delayed operation for future execution, and return the operation identifier. It is possible to
+ * choose the timestamp at which the operation becomes executable as long as it satisfies the execution delays
+ * required for the caller. The special value zero will automatically set the earliest possible time.
+ *
+ * Returns the `operationId` that was scheduled. Since this value is a hash of the parameters, it can reoccur when
+ * the same parameters are used; if this is relevant, the returned `nonce` can be used to uniquely identify this
+ * scheduled operation from other occurrences of the same `operationId` in invocations of {execute} and {cancel}.
+ *
+ * Emits a {OperationScheduled} event.
+ *
+ * NOTE: It is not possible to concurrently schedule more than one operation with the same `target` and `data`. If
+ * this is necessary, a random byte can be appended to `data` to act as a salt that will be ignored by the target
+ * contract if it is using standard Solidity ABI encoding.
+ */
+ function schedule(
+ address target,
+ bytes calldata data,
+ uint48 when
+ ) external returns (bytes32 operationId, uint32 nonce);
+
+ /**
+ * @dev Execute a function that is delay restricted, provided it was properly scheduled beforehand, or the
+ * execution delay is 0.
+ *
+ * Returns the nonce that identifies the previously scheduled operation that is executed, or 0 if the
+ * operation wasn't previously scheduled (if the caller doesn't have an execution delay).
+ *
+ * Emits an {OperationExecuted} event only if the call was scheduled and delayed.
+ */
+ function execute(address target, bytes calldata data) external payable returns (uint32);
+
+ /**
+ * @dev Cancel a scheduled (delayed) operation. Returns the nonce that identifies the previously scheduled
+ * operation that is cancelled.
+ *
+ * Requirements:
+ *
+ * - the caller must be the proposer, a guardian of the targeted function, or a global admin
+ *
+ * Emits a {OperationCanceled} event.
+ */
+ function cancel(address caller, address target, bytes calldata data) external returns (uint32);
+
+ /**
+ * @dev Consume a scheduled operation targeting the caller. If such an operation exists, mark it as consumed
+ * (emit an {OperationExecuted} event and clean the state). Otherwise, throw an error.
+ *
+ * This is useful for contract that want to enforce that calls targeting them were scheduled on the manager,
+ * with all the verifications that it implies.
+ *
+ * Emit a {OperationExecuted} event.
+ */
+ function consumeScheduledOp(address caller, bytes calldata data) external;
+
+ /**
+ * @dev Hashing function for delayed operations.
+ */
+ function hashOperation(address caller, address target, bytes calldata data) external view returns (bytes32);
+
+ /**
+ * @dev Changes the authority of a target managed by this manager instance.
+ *
+ * Requirements:
+ *
+ * - the caller must be a global admin
+ */
+ function updateAuthority(address target, address newAuthority) external;
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/access/manager/IAuthority.sol b/con/lib/openzeppelin-contracts/contracts/access/manager/IAuthority.sol
new file mode 100644
index 000000000..6ad902c74
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/access/manager/IAuthority.sol
@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (access/manager/IAuthority.sol)
+
+pragma solidity >=0.4.16;
+
+/**
+ * @dev Standard interface for permissioning originally defined in Dappsys.
+ */
+interface IAuthority {
+ /**
+ * @dev Returns true if the caller can invoke on a target the function identified by a function selector.
+ */
+ function canCall(address caller, address target, bytes4 selector) external view returns (bool allowed);
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/account/Account.sol b/con/lib/openzeppelin-contracts/contracts/account/Account.sol
new file mode 100644
index 000000000..19c64d7a6
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/account/Account.sol
@@ -0,0 +1,145 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (account/Account.sol)
+
+pragma solidity ^0.8.20;
+
+import {PackedUserOperation, IAccount, IEntryPoint} from "../interfaces/draft-IERC4337.sol";
+import {ERC4337Utils} from "./utils/draft-ERC4337Utils.sol";
+import {AbstractSigner} from "../utils/cryptography/signers/AbstractSigner.sol";
+
+/**
+ * @dev A simple ERC4337 account implementation. This base implementation only includes the minimal logic to process
+ * user operations.
+ *
+ * Developers must implement the {AbstractSigner-_rawSignatureValidation} function to define the account's validation logic.
+ *
+ * NOTE: This core account doesn't include any mechanism for performing arbitrary external calls. This is an essential
+ * feature that all Account should have. We leave it up to the developers to implement the mechanism of their choice.
+ * Common choices include ERC-6900, ERC-7579 and ERC-7821 (among others).
+ *
+ * IMPORTANT: Implementing a mechanism to validate signatures is a security-sensitive operation as it may allow an
+ * attacker to bypass the account's security measures. Check out {SignerECDSA}, {SignerP256}, or {SignerRSA} for
+ * digital signature validation implementations.
+ *
+ * @custom:stateless
+ */
+abstract contract Account is AbstractSigner, IAccount {
+ /**
+ * @dev Unauthorized call to the account.
+ */
+ error AccountUnauthorized(address sender);
+
+ /**
+ * @dev Revert if the caller is not the entry point or the account itself.
+ */
+ modifier onlyEntryPointOrSelf() {
+ _checkEntryPointOrSelf();
+ _;
+ }
+
+ /**
+ * @dev Revert if the caller is not the entry point.
+ */
+ modifier onlyEntryPoint() {
+ _checkEntryPoint();
+ _;
+ }
+
+ /**
+ * @dev Canonical entry point for the account that forwards and validates user operations.
+ */
+ function entryPoint() public view virtual returns (IEntryPoint) {
+ return ERC4337Utils.ENTRYPOINT_V08;
+ }
+
+ /**
+ * @dev Return the account nonce for the canonical sequence.
+ */
+ function getNonce() public view virtual returns (uint256) {
+ return getNonce(0);
+ }
+
+ /**
+ * @dev Return the account nonce for a given sequence (key).
+ */
+ function getNonce(uint192 key) public view virtual returns (uint256) {
+ return entryPoint().getNonce(address(this), key);
+ }
+
+ /**
+ * @inheritdoc IAccount
+ */
+ function validateUserOp(
+ PackedUserOperation calldata userOp,
+ bytes32 userOpHash,
+ uint256 missingAccountFunds
+ ) public virtual onlyEntryPoint returns (uint256) {
+ uint256 validationData = _validateUserOp(userOp, userOpHash);
+ _payPrefund(missingAccountFunds);
+ return validationData;
+ }
+
+ /**
+ * @dev Returns the validationData for a given user operation. By default, this checks the signature of the
+ * signable hash (produced by {_signableUserOpHash}) using the abstract signer ({AbstractSigner-_rawSignatureValidation}).
+ *
+ * NOTE: The userOpHash is assumed to be correct. Calling this function with a userOpHash that does not match the
+ * userOp will result in undefined behavior.
+ */
+ function _validateUserOp(
+ PackedUserOperation calldata userOp,
+ bytes32 userOpHash
+ ) internal virtual returns (uint256) {
+ return
+ _rawSignatureValidation(_signableUserOpHash(userOp, userOpHash), userOp.signature)
+ ? ERC4337Utils.SIG_VALIDATION_SUCCESS
+ : ERC4337Utils.SIG_VALIDATION_FAILED;
+ }
+
+ /**
+ * @dev Virtual function that returns the signable hash for a user operations. Since v0.8.0 of the entrypoint,
+ * `userOpHash` is an EIP-712 hash that can be signed directly.
+ */
+ function _signableUserOpHash(
+ PackedUserOperation calldata /*userOp*/,
+ bytes32 userOpHash
+ ) internal view virtual returns (bytes32) {
+ return userOpHash;
+ }
+
+ /**
+ * @dev Sends the missing funds for executing the user operation to the {entrypoint}.
+ * The `missingAccountFunds` must be defined by the entrypoint when calling {validateUserOp}.
+ */
+ function _payPrefund(uint256 missingAccountFunds) internal virtual {
+ if (missingAccountFunds > 0) {
+ (bool success, ) = payable(msg.sender).call{value: missingAccountFunds}("");
+ success; // Silence warning. The entrypoint should validate the result.
+ }
+ }
+
+ /**
+ * @dev Ensures the caller is the {entrypoint}.
+ */
+ function _checkEntryPoint() internal view virtual {
+ address sender = msg.sender;
+ if (sender != address(entryPoint())) {
+ revert AccountUnauthorized(sender);
+ }
+ }
+
+ /**
+ * @dev Ensures the caller is the {entrypoint} or the account itself.
+ */
+ function _checkEntryPointOrSelf() internal view virtual {
+ address sender = msg.sender;
+ if (sender != address(this) && sender != address(entryPoint())) {
+ revert AccountUnauthorized(sender);
+ }
+ }
+
+ /**
+ * @dev Receive Ether.
+ */
+ receive() external payable virtual {}
+}
diff --git a/con/lib/openzeppelin-contracts/contracts/account/README.adoc b/con/lib/openzeppelin-contracts/contracts/account/README.adoc
new file mode 100644
index 000000000..dc3c9a010
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/account/README.adoc
@@ -0,0 +1,30 @@
+= Account
+[.readme-notice]
+NOTE: This document is better viewed at https://docs.openzeppelin.com/contracts/api/account
+
+This directory includes contracts to build accounts for ERC-4337. These include:
+
+ * {Account}: An ERC-4337 smart account implementation that includes the core logic to process user operations.
+ * {AccountERC7579}: An extension of `Account` that implements support for ERC-7579 modules.
+ * {AccountERC7579Hooked}: An extension of `AccountERC7579` with support for a single hook module (type 4).
+ * {ERC7821}: Minimal batch executor implementation contracts. Useful to enable easy batch execution for smart contracts.
+ * {ERC4337Utils}: Utility functions for working with ERC-4337 user operations.
+ * {ERC7579Utils}: Utility functions for working with ERC-7579 modules and account modularity.
+
+== Core
+
+{{Account}}
+
+== Extensions
+
+{{AccountERC7579}}
+
+{{AccountERC7579Hooked}}
+
+{{ERC7821}}
+
+== Utilities
+
+{{ERC4337Utils}}
+
+{{ERC7579Utils}}
diff --git a/con/lib/openzeppelin-contracts/contracts/account/extensions/draft-AccountERC7579.sol b/con/lib/openzeppelin-contracts/contracts/account/extensions/draft-AccountERC7579.sol
new file mode 100644
index 000000000..40ea71ed9
--- /dev/null
+++ b/con/lib/openzeppelin-contracts/contracts/account/extensions/draft-AccountERC7579.sol
@@ -0,0 +1,405 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.4.0) (account/extensions/draft-AccountERC7579.sol)
+
+pragma solidity ^0.8.26;
+
+import {PackedUserOperation} from "../../interfaces/draft-IERC4337.sol";
+import {IERC1271} from "../../interfaces/IERC1271.sol";
+import {IERC7579Module, IERC7579Validator, IERC7579Execution, IERC7579AccountConfig, IERC7579ModuleConfig, MODULE_TYPE_VALIDATOR, MODULE_TYPE_EXECUTOR, MODULE_TYPE_FALLBACK} from "../../interfaces/draft-IERC7579.sol";
+import {ERC7579Utils, Mode, CallType, ExecType} from "../../account/utils/draft-ERC7579Utils.sol";
+import {EnumerableSet} from "../../utils/structs/EnumerableSet.sol";
+import {Bytes} from "../../utils/Bytes.sol";
+import {Packing} from "../../utils/Packing.sol";
+import {Address} from "../../utils/Address.sol";
+import {Calldata} from "../../utils/Calldata.sol";
+import {Account} from "../Account.sol";
+
+/**
+ * @dev Extension of {Account} that implements support for ERC-7579 modules.
+ *
+ * To comply with the ERC-1271 support requirement, this contract defers signature validation to
+ * installed validator modules by calling {IERC7579Validator-isValidSignatureWithSender}.
+ *
+ * This contract does not implement validation logic for user operations since this functionality
+ * is often delegated to self-contained validation modules. Developers must install a validator module
+ * upon initialization (or any other mechanism to enable execution from the account):
+ *
+ * ```solidity
+ * contract MyAccountERC7579 is AccountERC7579, Initializable {
+ * function initializeAccount(address validator, bytes calldata validatorData) public initializer {
+ * _installModule(MODULE_TYPE_VALIDATOR, validator, validatorData);
+ * }
+ * }
+ * ```
+ *
+ * [NOTE]
+ * ====
+ * * Hook support is not included. See {AccountERC7579Hooked} for a version that hooks to execution.
+ * * Validator selection, when verifying either ERC-1271 signature or ERC-4337 UserOperation is implemented in
+ * internal virtual functions {_extractUserOpValidator} and {_extractSignatureValidator}. Both are implemented
+ * following common practices. However, this part is not standardized in ERC-7579 (or in any follow-up ERC). Some
+ * accounts may want to override these internal functions.
+ * * When combined with {ERC7739}, resolution ordering of {isValidSignature} may have an impact ({ERC7739} does not
+ * call super). Manual resolution might be necessary.
+ * * Static calls (using callType `0xfe`) are currently NOT supported.
+ * ====
+ *
+ * WARNING: Removing all validator modules will render the account inoperable, as no user operations can be validated thereafter.
+ */
+abstract contract AccountERC7579 is Account, IERC1271, IERC7579Execution, IERC7579AccountConfig, IERC7579ModuleConfig {
+ using Bytes for *;
+ using ERC7579Utils for *;
+ using EnumerableSet for *;
+ using Packing for bytes32;
+
+ EnumerableSet.AddressSet private _validators;
+ EnumerableSet.AddressSet private _executors;
+ mapping(bytes4 selector => address) private _fallbacks;
+
+ /// @dev The account's {fallback} was called with a selector that doesn't have an installed handler.
+ error ERC7579MissingFallbackHandler(bytes4 selector);
+
+ /// @dev Modifier that checks if the caller is an installed module of the given type.
+ modifier onlyModule(uint256 moduleTypeId, bytes calldata additionalContext) {
+ _checkModule(moduleTypeId, msg.sender, additionalContext);
+ _;
+ }
+
+ /// @dev See {_fallback}.
+ fallback(bytes calldata) external payable virtual returns (bytes memory) {
+ return _fallback();
+ }
+
+ /// @inheritdoc IERC7579AccountConfig
+ function accountId() public view virtual returns (string memory) {
+ // vendorname.accountname.semver
+ return "@openzeppelin/community-contracts.AccountERC7579.v0.0.0";
+ }
+
+ /**
+ * @inheritdoc IERC7579AccountConfig
+ *
+ * @dev Supported call types:
+ * * Single (`0x00`): A single transaction execution.
+ * * Batch (`0x01`): A batch of transactions execution.
+ * * Delegate (`0xff`): A delegate call execution.
+ *
+ * Supported exec types:
+ * * Default (`0x00`): Default execution type (revert on failure).
+ * * Try (`0x01`): Try execution type (emits ERC7579TryExecuteFail on failure).
+ */
+ function supportsExecutionMode(bytes32 encodedMode) public view virtual returns (bool) {
+ (CallType callType, ExecType execType, , ) = Mode.wrap(encodedMode).decodeMode();
+ return
+ (callType == ERC7579Utils.CALLTYPE_SINGLE ||
+ callType == ERC7579Utils.CALLTYPE_BATCH ||
+ callType == ERC7579Utils.CALLTYPE_DELEGATECALL) &&
+ (execType == ERC7579Utils.EXECTYPE_DEFAULT || execType == ERC7579Utils.EXECTYPE_TRY);
+ }
+
+ /**
+ * @inheritdoc IERC7579AccountConfig
+ *
+ * @dev Supported module types:
+ *
+ * * Validator: A module used during the validation phase to determine if a transaction is valid and
+ * should be executed on the account.
+ * * Executor: A module that can execute transactions on behalf of the smart account via a callback.
+ * * Fallback Handler: A module that can extend the fallback functionality of a smart account.
+ */
+ function supportsModule(uint256 moduleTypeId) public view virtual returns (bool) {
+ return
+ moduleTypeId == MODULE_TYPE_VALIDATOR ||
+ moduleTypeId == MODULE_TYPE_EXECUTOR ||
+ moduleTypeId == MODULE_TYPE_FALLBACK;
+ }
+
+ /// @inheritdoc IERC7579ModuleConfig
+ function installModule(
+ uint256 moduleTypeId,
+ address module,
+ bytes calldata initData
+ ) public virtual onlyEntryPointOrSelf {
+ _installModule(moduleTypeId, module, initData);
+ }
+
+ /// @inheritdoc IERC7579ModuleConfig
+ function uninstallModule(
+ uint256 moduleTypeId,
+ address module,
+ bytes calldata deInitData
+ ) public virtual onlyEntryPointOrSelf {
+ _uninstallModule(moduleTypeId, module, deInitData);
+ }
+
+ /// @inheritdoc IERC7579ModuleConfig
+ function isModuleInstalled(
+ uint256 moduleTypeId,
+ address module,
+ bytes calldata additionalContext
+ ) public view virtual returns (bool) {
+ if (moduleTypeId == MODULE_TYPE_VALIDATOR) return _validators.contains(module);
+ if (moduleTypeId == MODULE_TYPE_EXECUTOR) return _executors.contains(module);
+ if (moduleTypeId == MODULE_TYPE_FALLBACK) return _fallbacks[bytes4(additionalContext[0:4])] == module;
+ return false;
+ }
+
+ /// @inheritdoc IERC7579Execution
+ function execute(bytes32 mode, bytes calldata executionCalldata) public payable virtual onlyEntryPointOrSelf {
+ _execute(Mode.wrap(mode), executionCalldata);
+ }
+
+ /// @inheritdoc IERC7579Execution
+ function executeFromExecutor(
+ bytes32 mode,
+ bytes calldata executionCalldata
+ )
+ public
+ payable
+ virtual
+ onlyModule(MODULE_TYPE_EXECUTOR, Calldata.emptyBytes())
+ returns (bytes[] memory returnData)
+ {
+ return _execute(Mode.wrap(mode), executionCalldata);
+ }
+
+ /**
+ * @dev Implement ERC-1271 through IERC7579Validator modules. If module based validation fails, fallback to
+ * "native" validation by the abstract signer.
+ *
+ * NOTE: when combined with {ERC7739}, resolution ordering may have an impact ({ERC7739} does not call super).
+ * Manual resolution might be necessary.
+ */
+ function isValidSignature(bytes32 hash, bytes calldata signature) public view virtual returns (bytes4) {
+ // check signature length is enough for extraction
+ if (signature.length >= 20) {
+ (address module, bytes calldata innerSignature) = _extractSignatureValidator(signature);
+ // if module is not installed, skip
+ if (isModuleInstalled(MODULE_TYPE_VALIDATOR, module, Calldata.emptyBytes())) {
+ // try validation, skip any revert
+ try IERC7579Validator(module).isValidSignatureWithSender(msg.sender, hash, innerSignature) returns (
+ bytes4 magic
+ ) {
+ return magic;
+ } catch {}
+ }
+ }
+ return bytes4(0xffffffff);
+ }
+
+ /**
+ * @dev Validates a user operation with {_signableUserOpHash} and returns the validation data
+ * if the module specified by the first 20 bytes of the nonce key is installed. Falls back to
+ * {Account-_validateUserOp} otherwise.
+ *
+ * See {_extractUserOpValidator} for the module extraction logic.
+ */
+ function _validateUserOp(
+ PackedUserOperation calldata userOp,
+ bytes32 userOpHash
+ ) internal virtual override returns (uint256) {
+ address module = _extractUserOpValidator(userOp);
+ return
+ isModuleInstalled(MODULE_TYPE_VALIDATOR, module, Calldata.emptyBytes())
+ ? IERC7579Validator(module).validateUserOp(userOp, _signableUserOpHash(userOp, userOpHash))
+ : super._validateUserOp(userOp, userOpHash);
+ }
+
+ /**
+ * @dev ERC-7579 execution logic. See {supportsExecutionMode} for supported modes.
+ *
+ * Reverts if the call type is not supported.
+ */
+ function _execute(
+ Mode mode,
+ bytes calldata executionCalldata
+ ) internal virtual returns (bytes[] memory returnData) {
+ (CallType callType, ExecType execType, , ) = mode.decodeMode();
+ if (callType == ERC7579Utils.CALLTYPE_SINGLE) return executionCalldata.execSingle(execType);
+ if (callType == ERC7579Utils.CALLTYPE_BATCH) return executionCalldata.execBatch(execType);
+ if (callType == ERC7579Utils.CALLTYPE_DELEGATECALL) return executionCalldata.execDelegateCall(execType);
+ revert ERC7579Utils.ERC7579UnsupportedCallType(callType);
+ }
+
+ /**
+ * @dev Installs a module of the given type with the given initialization data.
+ *
+ * For the fallback module type, the `initData` is expected to be the (packed) concatenation of a 4-byte
+ * selector and the rest of the data to be sent to the handler when calling {IERC7579Module-onInstall}.
+ *
+ * Requirements:
+ *
+ * * Module type must be supported. See {supportsModule}. Reverts with {ERC7579Utils-ERC7579UnsupportedModuleType}.
+ * * Module must be of the given type. Reverts with {ERC7579Utils-ERC7579MismatchedModuleTypeId}.
+ * * Module must not be already installed. Reverts with {ERC7579Utils-ERC7579AlreadyInstalledModule}.
+ *
+ * Emits a {IERC7579ModuleConfig-ModuleInstalled} event.
+ */
+ function _installModule(uint256 moduleTypeId, address module, bytes memory initData) internal virtual {
+ require(supportsModule(moduleTypeId), ERC7579Utils.ERC7579UnsupportedModuleType(moduleTypeId));
+ require(
+ IERC7579Module(module).isModuleType(moduleTypeId),
+ ERC7579Utils.ERC7579MismatchedModuleTypeId(moduleTypeId, module)
+ );
+
+ if (moduleTypeId == MODULE_TYPE_VALIDATOR) {
+ require(_validators.add(module), ERC7579Utils.ERC7579AlreadyInstalledModule(moduleTypeId, module));
+ } else if (moduleTypeId == MODULE_TYPE_EXECUTOR) {
+ require(_executors.add(module), ERC7579Utils.ERC7579AlreadyInstalledModule(moduleTypeId, module));
+ } else if (moduleTypeId == MODULE_TYPE_FALLBACK) {
+ bytes4 selector;
+ (selector, initData) = _decodeFallbackData(initData);
+ require(
+ _fallbacks[selector] == address(0),
+ ERC7579Utils.ERC7579AlreadyInstalledModule(moduleTypeId, module)
+ );
+ _fallbacks[selector] = module;
+ }
+
+ IERC7579Module(module).onInstall(initData);
+ emit ModuleInstalled(moduleTypeId, module);
+ }
+
+ /**
+ * @dev Uninstalls a module of the given type with the given de-initialization data.
+ *
+ * For the fallback module type, the `deInitData` is expected to be the (packed) concatenation of a 4-byte
+ * selector and the rest of the data to be sent to the handler when calling {IERC7579Module-onUninstall}.
+ *
+ * Requirements:
+ *
+ * * Module must be already installed. Reverts with {ERC7579Utils-ERC7579UninstalledModule} otherwise.
+ */
+ function _uninstallModule(uint256 moduleTypeId, address module, bytes memory deInitData) internal virtual {
+ require(supportsModule(moduleTypeId), ERC7579Utils.ERC7579UnsupportedModuleType(moduleTypeId));
+
+ if (moduleTypeId == MODULE_TYPE_VALIDATOR) {
+ require(_validators.remove(module), ERC7579Utils.ERC7579UninstalledModule(moduleTypeId, module));
+ } else if (moduleTypeId == MODULE_TYPE_EXECUTOR) {
+ require(_executors.remove(module), ERC7579Utils.ERC7579UninstalledModule(moduleTypeId, module));
+ } else if (moduleTypeId == MODULE_TYPE_FALLBACK) {
+ bytes4 selector;
+ (selector, deInitData) = _decodeFallbackData(deInitData);
+ require(
+ _fallbackHandler(selector) == module && module != address(0),
+ ERC7579Utils.ERC7579UninstalledModule(moduleTypeId, module)
+ );
+ delete _fallbacks[selector];
+ }
+
+ IERC7579Module(module).onUninstall(deInitData);
+ emit ModuleUninstalled(moduleTypeId, module);
+ }
+
+ /**
+ * @dev Fallback function that delegates the call to the installed handler for the given selector.
+ *
+ * Reverts with {ERC7579MissingFallbackHandler} if the handler is not installed.
+ *
+ * Calls the handler with the original `msg.sender` appended at the end of the calldata following
+ * the ERC-2771 format.
+ */
+ function _fallback() internal virtual returns (bytes memory) {
+ address handler = _fallbackHandler(msg.sig);
+ require(handler != address(0), ERC7579MissingFallbackHandler(msg.sig));
+
+ // From https://eips.ethereum.org/EIPS/eip-7579#fallback[ERC-7579 specifications]:
+ // - MUST utilize ERC-2771 to add the original msg.sender to the calldata sent to the fallback handler
+ // - MUST use call to invoke the fallback handler
+ (bool success, bytes memory returndata) = handler.call{value: msg.value}(
+ abi.encodePacked(msg.data, msg.sender)
+ );
+
+ if (success) return returndata;
+
+ assembly ("memory-safe") {
+ revert(add(returndata, 0x20), mload(returndata))
+ }
+ }
+
+ /// @dev Returns the fallback handler for the given selector. Returns `address(0)` if not installed.
+ function _fallbackHandler(bytes4 selector) internal view virtual returns (address) {
+ return _fallbacks[selector];
+ }
+
+ /// @dev Checks if the module is installed. Reverts if the module is not installed.
+ function _checkModule(
+ uint256 moduleTypeId,
+ address module,
+ bytes calldata additionalContext
+ ) internal view virtual {
+ require(
+ isModuleInstalled(moduleTypeId, module, additionalContext),
+ ERC7579Utils.ERC7579UninstalledModule(moduleTypeId, module)
+ );
+ }
+
+ /**
+ * @dev Extracts the nonce validator from the user operation.
+ *
+ * To construct a nonce key, set nonce as follows:
+ *
+ * ```
+ *
+
+ {/* Progress Steps */}
+
+
+ );
+}
diff --git a/src/components/index.ts b/src/components/index.ts
new file mode 100644
index 000000000..47b3e6ffb
--- /dev/null
+++ b/src/components/index.ts
@@ -0,0 +1 @@
+export * from "./swap";
diff --git a/src/components/layout/Header.tsx b/src/components/layout/Header.tsx
new file mode 100644
index 000000000..3f550a2e5
--- /dev/null
+++ b/src/components/layout/Header.tsx
@@ -0,0 +1,32 @@
+'use client';
+
+import { WalletConnect } from '@/components/wallet/WalletConnect';
+
+export function Header() {
+ return (
+
+
+
+
+ S
+
+ SwapInAd
+
+
+
+
+
+
+ );
+};
diff --git a/src/components/swap/NFTBadgeReward.tsx b/src/components/swap/NFTBadgeReward.tsx
new file mode 100644
index 000000000..28f00f646
--- /dev/null
+++ b/src/components/swap/NFTBadgeReward.tsx
@@ -0,0 +1,440 @@
+import { useState, useEffect } from "react";
+
+interface NFTBadgeRewardProps {
+ fromAmount: string;
+ toAmount: string;
+ fromToken: { symbol: string } | null;
+ toToken: { symbol: string } | null;
+ onNewSwap: () => void;
+}
+
+interface BadgeAttribute {
+ trait_type: string;
+ value: string | number;
+}
+
+interface FloatingElement {
+ id: number;
+ emoji: string;
+ x: number;
+ y: number;
+ delay: number;
+ duration: number;
+}
+
+const badgeAttributes: BadgeAttribute[] = [
+ { trait_type: "Survival Status", value: "Legendary Survivor" },
+ { trait_type: "Comedy Tolerance", value: "Maximum" },
+ { trait_type: "Pizza Approval", value: "Witnessed" },
+ { trait_type: "Gas Roulette", value: "Spun" },
+ { trait_type: "Community Validation", value: "Approved" },
+ { trait_type: "Over-Engineering Level", value: "โ" },
+ { trait_type: "Elton's Rating", value: "5 Stars" },
+ { trait_type: "Completion Date", value: new Date().toLocaleDateString() },
+];
+
+export const NFTBadgeReward = ({
+ fromAmount,
+ toAmount,
+ fromToken,
+ toToken,
+ onNewSwap,
+}: NFTBadgeRewardProps) => {
+ const [mintingStage, setMintingStage] = useState<
+ "preparation" | "minting" | "complete"
+ >("preparation");
+ const [currentAttribute, setCurrentAttribute] = useState(0);
+ const [showNFTPreview, setShowNFTPreview] = useState(false);
+ const [badgeGenerated, setBadgeGenerated] = useState(false);
+ const [floatingElements, setFloatingElements] = useState
+
+
+
+
+
+ Swap Complete!
++ Your tokens have been successfully swapped +
+
+
+
+
+ You Sent:
+ {fromAmount} BNB
+
+
+ You Received:
+ {toAmount} USDT
+
+
+ Transaction Hash:
+ 0x1234...abcd
+
+
+ Block Number:
+ 18,234,567
+
+
+
+
+
+
+ {/* Badge Background */}
+
+ );
+
+ return (
+
+ {/* Inner Ring */}
+
+
+ {/* Glowing Effect */}
+
+
+ {/* Center Content */}
+
+
+ {/* Achievement Ribbon */}
+
+
+ ๐
+
+ SWAP SURVIVOR
+
+
+ {new Date().getFullYear()}
+
+
+ {/* Decorative Stars */}
+
+ โญ
+
+
+ โญ
+
+
+ โญ
+
+
+ โญ
+
+
+ LEGENDARY
+
+
+ {/* Floating celebration elements */}
+ {badgeGenerated &&
+ floatingElements.map((element) => (
+
+ );
+};
diff --git a/src/components/swap/PizzaApproval.tsx b/src/components/swap/PizzaApproval.tsx
new file mode 100644
index 000000000..2b45b1904
--- /dev/null
+++ b/src/components/swap/PizzaApproval.tsx
@@ -0,0 +1,359 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { SwapExecutionProgress } from "@/services/swapExecution";
+
+interface PizzaApprovalProps {
+ progress?: SwapExecutionProgress | null;
+ onComplete?: () => void;
+ onExecuteSwap?: () => void;
+}
+
+interface PizzaBite {
+ id: number;
+ angle: number;
+ eaten: boolean;
+}
+
+const eltonDialogue = [
+ "Hmm, let me examine this transaction...",
+ "*takes a big bite* ๐ Mmm...",
+ "*chew chew* This swap seems legitimate...",
+ "*another bite* The gas fees look reasonable...",
+ "*chew chew chew* Token addresses check out...",
+ "*nom nom* Slippage tolerance is acceptable...",
+ "*chew* Almost done with my analysis...",
+ "*final bite* Perfect! Transaction approved! ๐",
+];
+
+export const PizzaApproval = ({
+ progress,
+ onComplete,
+ onExecuteSwap,
+}: PizzaApprovalProps) => {
+ const [currentBite, setCurrentBite] = useState(0);
+ const [eltonThoughts, setEltonThoughts] = useState(
+ "Hmm, let me examine this transaction..."
+ );
+ const [approvalComplete, setApprovalComplete] = useState(false);
+ const [showRealStatus, setShowRealStatus] = useState(false);
+ const executionStartedRef = useRef(false);
+
+ // Create 8 pizza slices - memoized to prevent re-creation
+ const [pizzaBites, setPizzaBites] = useState
+ {element.emoji}
+
+ ))}
+
+ {/* Header */}
+
+
+
+ {/* Minting Progress */}
+ {mintingStage !== "complete" && (
+ ๐
+ + {mintingStage === "preparation" && "๐จ Preparing Your NFT Badge..."} + {mintingStage === "minting" && "โก Minting Your Achievement..."} + {mintingStage === "complete" && "๐ NFT Badge Minted Successfully!"} +
++ {mintingStage === "complete" + ? "Congratulations! You now own a legendary 'I Survived The Swap' NFT badge!" + : "Creating your unique survival certificate..."} +
+
+
+ )}
+
+ {/* NFT Badge Preview */}
+ {showNFTPreview && (
+
+
+
+
+
+ {/* Progress Animation */}
+
+
+
+ {mintingStage === "preparation"
+ ? "Preparing NFT..."
+ : "Minting in Progress..."}
+
+
+
+
+
+
+ {/* Current Attribute Being Added */}
+ {mintingStage === "minting" && (
+
+
+ )}
+ Adding attribute:
+
+ {badgeAttributes[currentAttribute]?.trait_type}:{" "}
+ {badgeAttributes[currentAttribute]?.value}
+
+ {renderBadgeDesign()}
+ )}
+
+ {/* NFT Details */}
+ {badgeGenerated && (
+
+ {/* NFT Metadata */}
+
+ )}
+
+ {/* Badge Attributes */}
+ {badgeGenerated && (
+
+
+
+ {/* Swap Summary */}
+ + ๐ + NFT Metadata +
+
+
+
+ Name:
+
+ “I Survived The Swap”
+
+
+
+ Collection:
+
+ Elton's Over-Engineered Survivors
+
+
+
+ Token Standard:
+ ERC-721
+
+
+ Rarity:
+ LEGENDARY
+
+
+
+ + ๐ + Your Epic Journey +
+
+
+
+ Swapped:
+
+ {fromAmount} {fromToken?.symbol}
+
+
+
+ Received:
+
+ {toAmount} {toToken?.symbol}
+
+
+
+ Steps Survived:
+ 6/6 โ
+
+
+ Comedy Level:
+ Maximum ๐ญ
+
+
+
+ )}
+
+ {/* Hall of Fame */}
+ {badgeGenerated && (
+ + ๐ Badge Attributes +
+
+ {badgeAttributes.map((attr, index) => (
+
+
+
+ ))}
+
+ {attr.trait_type}
+
+
+ {attr.value}
+
+
+
+ )}
+
+ {/* Action Buttons */}
+ {badgeGenerated && (
+ + ๐ Welcome to the Hall of Fame +
+
+
+ + You are now officially a member of the exclusive “Swap + Survivors” club! +
+
+
+
+
+ ๐ฅ
+ Gold Tier
+ Legendary Survivor
+
+
+ ๐ญ
+ Comedy Master
+
+ Survived All Theatrics
+
+
+
+ ๐
+ DeFi Explorer
+
+ Completed The Journey
+
+
+
+
+
+
+ )}
+
+ {/* Final Message */}
+ {badgeGenerated && (
+
+
+ )}
+
+
+ ๐
+ + “Thank you for surviving my over-engineered masterpiece! You + are now forever part of DeFi comedy history.” +
++ - Chef Elton, Creator of Theatrical Swaps +
+
+
+ );
+};
diff --git a/src/components/swap/Processing.tsx b/src/components/swap/Processing.tsx
new file mode 100644
index 000000000..bf850b6d9
--- /dev/null
+++ b/src/components/swap/Processing.tsx
@@ -0,0 +1,421 @@
+import { useState, useEffect } from "react";
+import {
+ SwapExecutionProgress,
+ formatTransactionHash,
+} from "@/services/swapExecution";
+
+interface ProcessingProps {
+ progress?: SwapExecutionProgress | null;
+ isExecuting?: boolean;
+ onComplete?: () => void;
+}
+
+interface Validator {
+ id: string;
+ name: string;
+ avatar: string;
+ bio: string;
+ approvalRate: number;
+ status: "reviewing" | "approved" | "pending";
+ comment: string;
+ voteTime: number; // seconds to vote
+}
+
+// Fake validator pool - moved outside component to prevent re-creation
+const validatorPool: Validator[] = [
+ {
+ id: "1",
+ name: "CryptoGrandma47",
+ avatar: "๐ต",
+ bio: "Professional blockchain validator since 2021, loves cats and DeFi",
+ approvalRate: 99.2,
+ status: "pending",
+ comment: "Looks legit to me! ๐",
+ voteTime: 2000,
+ },
+ {
+ id: "2",
+ name: "DogeCoinMiner2009",
+ avatar: "๐",
+ bio: "Much validator, very approve, wow!",
+ approvalRate: 97.8,
+ status: "pending",
+ comment: "Such legitimate transaction, much approve! ๐",
+ voteTime: 1500,
+ },
+ {
+ id: "3",
+ name: "ElonMuskFan420",
+ avatar: "๐",
+ bio: "To the moon! Professional rocket validator",
+ approvalRate: 94.5,
+ status: "pending",
+ comment: "This transaction is going to Mars! โ
",
+ voteTime: 2500,
+ },
+ {
+ id: "4",
+ name: "PizzaValidatorPro",
+ avatar: "๐",
+ bio: "Validating transactions since 2017, powered by pizza",
+ approvalRate: 98.1,
+ status: "pending",
+ comment: "Approved! This deserves extra cheese ๐ง",
+ voteTime: 1800,
+ },
+ {
+ id: "5",
+ name: "BlockchainBob",
+ avatar: "๐ค",
+ bio: "PhD in Crypto, expert in legitimate transactions",
+ approvalRate: 99.7,
+ status: "pending",
+ comment: "After careful analysis: APPROVED โ
",
+ voteTime: 3000,
+ },
+ {
+ id: "6",
+ name: "CoffeeChainValidator",
+ avatar: "โ",
+ bio: "Fueled by caffeine, powered by blockchain",
+ approvalRate: 96.3,
+ status: "pending",
+ comment: "Approved faster than my morning brew! โก",
+ voteTime: 1200,
+ },
+];
+
+export const Processing = ({ progress, onComplete }: ProcessingProps) => {
+ const [validators, setValidators] = useState
+
+
+ {/* Elton Character */}
+ + ๐ Elton's Pizza Approval +
++ Elton must finish his pizza before approving your transaction +
+
+
+
+
+
+ {approvalComplete ? "Approval Complete" : "Analyzing Transaction"}
+
+
+
+
+
+ {/* Elton's Thoughts */}
+
+
+
+ ๐จโ๐ณ
+
+
+ {currentBite < 8 && (
+
+
+ {currentBite % 2 === 0 ? "๐" : "๐คค"}
+
+ )}
+ Chef Elton
++ Professional Transaction Taster & Blockchain Chef +
+
+
+
+ {/* Pizza Visual */}
+
+
+
+
+
+
+
+
+ “{eltonThoughts}”
+
+ {currentBite < 8 && (
+
+ Thinking...
+
+ )}
+
+
+
+
+
+
+
+
+ {/* Progress Bar */}
+
+ {/* Pizza Base */}
+
+
+ {/* Main pizza base with pastel colors */}
+
+
+ {/* Crust texture */}
+
+
+ {/* Pizza sauce layer */}
+
+
+ {/* Pizza Slices */}
+ {pizzaBites.map((bite) => (
+
+ {/* Sauce texture */}
+
+
+
+ {/* Cheese layer */}
+
+ {/* Cheese bubbles effect */}
+
+
+
+
+
+
+ {/* Toppings */}
+
+ {/* Pepperoni */}
+
+
+
+
+
+ {/* Mushrooms */}
+
+
+
+ {/* Basil leaves */}
+
+
+
+
+ {/* Slice outline with pastel colors */}
+
+
+ ))}
+
+ {/* Eating Animation */}
+ {currentBite < 8 && (
+
+
+ )}
+
+ {currentBite % 3 === 0
+ ? "๐ฝ๏ธ"
+ : currentBite % 3 === 1
+ ? "๐"
+ : "๐คค"}
+
+
+
+
+ {/* Approval Stats */}
+ {approvalComplete && (
+
+
+
+ Pizza Progress:
+
+ {eatenSlices}/8 slices
+ {approvalComplete && (
+ ๐ APPROVED!
+ )}
+
+
+
+
+
+ {/* Progress bar shimmer effect */}
+
+
+
+ {approvalComplete
+ ? "๐ Analysis Complete - Transaction Approved!"
+ : `${Math.round(progressPercentage)}% analyzed`}
+
+
+
+ )}
+
+ {/* Real Transaction Status */}
+ {showRealStatus && progress && (
+ + ๐ Chef's Analysis Results +
+
+
+
+
+
+ A+
+
+ Transaction Grade
+
+
+
+ 8/8
+
+ Pizza Slices
+
+
+
+ 100%
+
+ Satisfaction
+
+
+ + ๐ Delicious transaction! Elton approves with 5 stars and extra + cheese! +
+
+
+ )}
+
+ {/* Bottom Message */}
+ + โก + Blockchain Status +
+
+
+
+ Transaction Status:
+
+
+
+ Completed
+
+
+ Chef Approval:
+ โ
Approved
+
+
+ Taste Rating:
+ ๐๐๐๐๐
+
+
+
+ + {approvalComplete && showRealStatus + ? "๐ Chef Elton has finished his pizza and approved your transaction!" + : approvalComplete + ? "โณ Pizza analysis complete, finalizing approval..." + : "๐ Elton is carefully tasting each aspect of your transaction..."} +
+
+
+ );
+ }
+
+ // Show fake community validation UI
+ return (
+
+
+
+
+ ๐ฏ
+
+ + Transaction Processing +
+Real blockchain status
+
+
+
+
+
+ Status
+
+ {progress.step === "complete" ? "Complete" : progress.message}
+
+
+
+ {progress.transactionHash && (
+
+ Transaction Hash
+
+ )}
+
+ {progress.transactionHash && (
+
+ )}
+
+ {formatTransactionHash(progress.transactionHash)}
+
+
+
+ );
+};
diff --git a/src/components/swap/ProgressSteps.tsx b/src/components/swap/ProgressSteps.tsx
new file mode 100644
index 000000000..59249d62f
--- /dev/null
+++ b/src/components/swap/ProgressSteps.tsx
@@ -0,0 +1,83 @@
+import { SwapStep } from "@/types/swap";
+
+interface ProgressStepsProps {
+ steps: SwapStep[];
+ currentStep: number;
+ onStepClick: (stepId: number) => void;
+}
+
+export const ProgressSteps = ({
+ steps,
+ currentStep,
+ onStepClick,
+}: ProgressStepsProps) => {
+ return (
+
+
+
+
+ ๐๏ธ
+
+ + ๐ณ๏ธ Community Validation +
++ Our network of 2,847 validators are reviewing your transaction... +
+ {!votingStarted && ( ++ Collecting consensus... +
+ )} +
+ {/* Progress Steps */}
+
+
+ {votingComplete && !showRealStatus && (
+
+
+
+ {/* Active Validators */}
+
+
+ + ๐ Validation Progress +
+
+ {[
+ "Transaction Received",
+ "Security Validation",
+ "Liquidity Check",
+ "Network Verification",
+ "Final Approval",
+ ].map((step, index) => {
+ const currentStep = votingComplete
+ ? 5
+ : votingStarted
+ ? Math.min(currentVoter + 2, 4)
+ : 0;
+ return (
+
+
+
+ );
+ })}
+
+
+ {getStepIcon(index, currentStep)}
+
+
+
+
+ {step}
+
+ {getStepStatus(index, currentStep)}
+
+
+
+
+
+ + ๐ฅ Active Validators +
+ +
+ {validators.map((validator, index) => (
+
+
+
+ ))}
+
+
+
+
+
+
+ {validator.avatar}
+
+ {validator.status === "approved" && (
+
+ โ
+
+ )}
+ {validator.status === "reviewing" &&
+ index === currentVoter && (
+
+ โก
+
+ )}
+
+
+
+
+
+ + {validator.name} +
+
+
+ {validator.approvalRate}% โ
+
+
+ + {validator.bio} +
+ + {validator.status === "approved" && ( +
+
+ )}
+
+ {validator.status === "reviewing" &&
+ index === currentVoter && (
+ + "{validator.comment}" +
+
+
+ )}
+ + Reviewing transaction details... +
+
+
+ )}
+
+ {/* Bottom feedback messages */}
+ {votingStarted && !votingComplete && (
+
+ ๐
+
+ + Community Approved! +
++ Your transaction has been validated by the community +
+
+ Proceeding to blockchain execution...
+
+
+
+ )}
+
+ {votingComplete && !showRealStatus && (
+
+
+ + ๐๏ธ + Validators are deliberating... + โ๏ธ +
+
+
+ )}
+
+
+ + โ + Consensus reached! Moving to blockchain... + ๐ +
+
+
+ );
+};
diff --git a/src/components/swap/ReviewConfirm.tsx b/src/components/swap/ReviewConfirm.tsx
new file mode 100644
index 000000000..6c04503c6
--- /dev/null
+++ b/src/components/swap/ReviewConfirm.tsx
@@ -0,0 +1,427 @@
+import { useState, useRef, useEffect } from "react";
+import { usePoolReserves } from "@/hooks/useSimpleSwapPool";
+import { Token } from "@/types/swap";
+
+interface ReviewConfirmProps {
+ fromAmount: string;
+ toAmount: string;
+ estimatedGas?: string;
+ exchangeRate?: string;
+ fromToken?: Token | null;
+ toToken?: Token | null;
+ onBack: () => void;
+ onNextStep: () => void;
+}
+
+export const ReviewConfirm = ({
+ fromAmount,
+ toAmount,
+ estimatedGas = "$2.50",
+ exchangeRate = "1 BNB = 35.573989 USDT",
+ fromToken,
+ toToken,
+ onBack,
+ onNextStep,
+}: ReviewConfirmProps) => {
+ const [isSpinning, setIsSpinning] = useState(false);
+ const [hasSpun, setHasSpun] = useState(false);
+ const [finalGasFee, setFinalGasFee] = useState(estimatedGas);
+ const [luckyPercentage, setLuckyPercentage] = useState(0);
+ const wheelRef = useRef
+ {steps.map((step, index) => {
+ const isActive = step.id === currentStep;
+ const isCompleted = step.id < currentStep;
+ const isUpcoming = step.id > currentStep;
+
+ return (
+
+
+
+ );
+ })}
+
+
+
+
+ {/* Progress Line between steps */}
+ {index < steps.length - 1 && (
+
+
+
+ )}
+
+
+ );
+};
diff --git a/src/components/swap/SwapInterface.tsx b/src/components/swap/SwapInterface.tsx
new file mode 100644
index 000000000..da949a243
--- /dev/null
+++ b/src/components/swap/SwapInterface.tsx
@@ -0,0 +1,185 @@
+"use client";
+
+import { TokenSelection } from "./TokenSelection";
+import { ReviewConfirm } from "./ReviewConfirm";
+import { Processing } from "./Processing";
+import { PizzaApproval } from "./PizzaApproval";
+import { TransactionComplete } from "./TransactionComplete";
+import { NFTBadgeReward } from "./NFTBadgeReward";
+import { TabNavigation } from "./TabNavigation";
+
+import { Token } from "@/types/swap";
+
+import { SwapExecutionProgress } from "@/services/swapExecution";
+
+interface SwapInterfaceProps {
+ currentStep: number;
+ fromAmount: string;
+ toAmount: string;
+ fromToken: Token | null;
+ toToken: Token | null;
+ exchangeRate: string | null;
+ estimatedGas?: number | null;
+ isLoadingPrice?: boolean;
+ priceError?: string | null;
+ isConnected?: boolean;
+ fromTokenBalance?: { formatted: string; symbol: string } | null;
+ toTokenBalance?: { formatted: string; symbol: string } | null;
+ isExecuting?: boolean;
+ executionProgress?: SwapExecutionProgress | null;
+ activeTab: string;
+ onFromAmountChange: (amount: string) => void;
+ onTabChange: (tab: string) => void;
+ onSwap: () => void;
+ onNextStep: () => void;
+ onBackToStep: (step: number) => void;
+ onExecuteSwap?: () => void;
+}
+
+export const SwapInterface = ({
+ currentStep,
+ fromAmount,
+ toAmount,
+ fromToken,
+ toToken,
+ exchangeRate,
+ estimatedGas,
+ isLoadingPrice,
+ priceError,
+ isConnected,
+ fromTokenBalance,
+ toTokenBalance,
+ isExecuting,
+ executionProgress,
+ activeTab,
+ onFromAmountChange,
+ onTabChange,
+ onSwap,
+ onNextStep,
+ onBackToStep,
+ onExecuteSwap,
+}: SwapInterfaceProps) => {
+ const renderStepContent = () => {
+ switch (currentStep) {
+ case 1:
+ return (
+ <>
+
+
+
+ ๐ฐ GMON Gas Roulette
+Spin to determine your GMON-denominated fee from our pool.
+ {!hasSpun && ( +Spinning the wheel of GMON destiny...
+ )} +
+ {/* Roulette Wheel */}
+
+
+ {isSpinning && (
+
+
+
+ {/* Transaction Details */}
+
+ {/* Spinning effect background */}
+ {isSpinning && (
+
+ )}
+
+ {/* Wheel Container */}
+
+
+ {/* Pointer */}
+
+
+ {/* Spin Button */}
+ {!hasSpun && (
+
+
+
+
+ {/* Spinning Wheel */}
+ {
+ const segmentAngle = 360 / rouletteOptions.length;
+ const startAngle = index * segmentAngle;
+ const endAngle = startAngle + segmentAngle;
+ return `${option.color} ${startAngle}deg ${endAngle}deg`;
+ })
+ .join(", ")})`,
+ }}
+ >
+ {/* Text labels */}
+ {rouletteOptions.map((option, index) => {
+ const segmentAngle = 360 / rouletteOptions.length;
+ const midAngle = index * segmentAngle + segmentAngle / 2;
+ const radius = 100; // Distance from center
+ const x =
+ 50 +
+ radius * Math.cos(((midAngle - 90) * Math.PI) / 180) * 0.7;
+ const y =
+ 50 +
+ radius * Math.sin(((midAngle - 90) * Math.PI) / 180) * 0.7;
+
+ return (
+
+
+ {/* Center Hub */}
+
+
+ );
+ })}
+
+ {option.fee}
+
+
+ {option.label}
+
+
+ ๐ฐ
+
+
+
+
+ )}
+
+ {/* Swap Container */}
+
+
+ {/* Swap Summary */}
+
+
+ {/* Pool Container */}
+
+
+ + ๐ Swap Summary +
+
+
+
+
+
+
+
+
+ B
+
+
+
+ {fromToken?.symbol || "MON"}
+ From
+
+
+
+ {fromAmount}
+
+
+
+
+
+ โ
+
+
+
+
+
+
+ โฎ
+
+
+
+ {toToken?.symbol || "GMON"}
+ To
+
+
+
+ {toAmount}
+
+
+ {/* Gas Fee Result */}
+
+
+ {/* Action Buttons Container */}
+ {hasSpun && (
+
+
+ โฝ Fee Verdict
+
+
+
+ Exchange Rate:
+ {exchangeRate}
+
+
+
+ Selected Gas Fee (fiat est.):
+
+ {hasSpun ? finalGasFee : "???"}
+
+
+
+ {hasSpun && gmonFee && (
+
+ GMON Fee (from pool):
+ {gmonFee}
+
+ )}
+
+ {reserves.data && (
+
+
+ )}
+
+ {hasSpun && (
+
+
+ Pool Native Reserve
+ {String((reserves.data as readonly [bigint, bigint])[0])}
+
+
+ Pool GMON Reserve
+ {String((reserves.data as readonly [bigint, bigint])[1])}
+
+
+ )}
+ + ๐ + The blockchain smiled upon you! Only {luckyPercentage}% of + users get fees this good! +
+
+
+ )}
+
+
+
+
+
+
+ )}
+
+ {hasSpun && (
+
+
+ + ๐ช + The GMON roulette is spinning... + โจ +
+
+
+ )}
+
+
+ + ๐ฏ + Your GMON fee has been selected! + ๐ซ +
+{renderStepContent()}
;
+};
diff --git a/src/components/swap/TabNavigation.tsx b/src/components/swap/TabNavigation.tsx
new file mode 100644
index 000000000..e5e12b971
--- /dev/null
+++ b/src/components/swap/TabNavigation.tsx
@@ -0,0 +1,34 @@
+interface TabNavigationProps {
+ activeTab: string;
+ onTabChange: (tab: string) => void;
+}
+
+export const TabNavigation = ({
+ activeTab,
+ onTabChange,
+}: TabNavigationProps) => {
+ return (
+
+
+
+
+ );
+};
diff --git a/src/components/swap/TokenSelection.tsx b/src/components/swap/TokenSelection.tsx
new file mode 100644
index 000000000..e7a908de1
--- /dev/null
+++ b/src/components/swap/TokenSelection.tsx
@@ -0,0 +1,340 @@
+import { Token } from "@/types/swap";
+
+interface TokenSelectionProps {
+ fromAmount: string;
+ toAmount: string;
+ fromToken: Token | null;
+ toToken: Token | null;
+ exchangeRate: string | null;
+ isLoadingPrice?: boolean;
+ priceError?: string | null;
+ isConnected?: boolean;
+ fromTokenBalance?: { formatted: string; symbol: string } | null;
+ toTokenBalance?: { formatted: string; symbol: string } | null;
+ onFromAmountChange: (amount: string) => void;
+ onSwap: () => void;
+ onNextStep: () => void;
+}
+
+export const TokenSelection = ({
+ fromAmount,
+ toAmount,
+ fromToken,
+ toToken,
+ exchangeRate,
+ isLoadingPrice = false,
+ priceError,
+ isConnected = false,
+ fromTokenBalance,
+ toTokenBalance,
+ onFromAmountChange,
+ onSwap,
+ onNextStep,
+}: TokenSelectionProps) => {
+ return (
+
+
+ );
+};
diff --git a/src/components/swap/TokenSelectorModal.tsx b/src/components/swap/TokenSelectorModal.tsx
new file mode 100644
index 000000000..e69de29bb
diff --git a/src/components/swap/TransactionComplete.tsx b/src/components/swap/TransactionComplete.tsx
new file mode 100644
index 000000000..7f4900df9
--- /dev/null
+++ b/src/components/swap/TransactionComplete.tsx
@@ -0,0 +1,546 @@
+import { useState, useEffect, useCallback, useRef } from "react";
+import { SwapExecutionProgress } from "@/services/swapExecution";
+import {
+ formatTransactionHash,
+ getTransactionUrl,
+} from "@/services/swapExecution";
+import { useChainId } from "wagmi";
+
+interface TransactionCompleteProps {
+ fromAmount: string;
+ toAmount: string;
+ fromToken: { symbol: string } | null;
+ toToken: { symbol: string } | null;
+ progress?: SwapExecutionProgress | null;
+ onNewSwap: () => void;
+ onNextStep?: () => void;
+}
+
+interface Celebration {
+ id: number;
+ icon: "star" | "sparkle" | "circle" | "diamond";
+ x: number;
+ y: number;
+ delay: number;
+ duration: number;
+}
+
+const celebrationMessages = [
+ "TRANSACTION SUCCESSFUL!",
+ "You've survived the over-engineered swap!",
+ "All theatrical delays were worth it!",
+ "Your tokens have been successfully swapped!",
+];
+
+// SVG Icon Components
+const CelebrationIcon = ({
+ type,
+ className = "",
+}: {
+ type: "star" | "sparkle" | "circle" | "diamond";
+ className?: string;
+}) => {
+ switch (type) {
+ case "star":
+ return (
+
+ );
+ case "sparkle":
+ return (
+
+ );
+ case "circle":
+ return (
+
+ );
+ case "diamond":
+ return (
+
+ );
+ default:
+ return null;
+ }
+};
+
+const TrophyIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+const CheckIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+const ChartIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+const RefreshIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+const GiftIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+const ExternalIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+const MedalIcon = ({ className = "" }: { className?: string }) => (
+
+);
+
+export const TransactionComplete = ({
+ fromAmount,
+ toAmount,
+ fromToken,
+ toToken,
+ progress,
+ onNewSwap,
+ onNextStep,
+}: TransactionCompleteProps) => {
+ const chainId = useChainId();
+ const [showCelebration, setShowCelebration] = useState(false);
+ const [currentMessage, setCurrentMessage] = useState(0);
+ const [showStats, setShowStats] = useState(false);
+ const [celebrations, setCelebrations] = useState
+
+
+ {/* Settings and Refresh Icons */}
+ + Select Your Tokens +
+Choose the tokens you want to swap
+
+
+
+
+
+ {/* From and To Sections Side by Side */}
+
+ {/* From Section */}
+
+
+ {/* Exchange Rate */}
+
+
+
+ {/* Swap Button Container */}
+
+ From:
+ 2er6d...8dfg2 N
+
+
+ Token
+ Network
+
+
+
+
+
+
+
+
+ {fromToken?.icon || fromToken?.symbol?.[0] || "?"}
+
+
+
+ {fromToken?.symbol || "Select Token"}
+
+
+
+
+
+ โ
+
+ Ethereum
+
+
+
+
+ You send:
+
+
+
+ {isConnected && fromTokenBalance
+ ? `Available: ${parseFloat(
+ fromTokenBalance.formatted
+ ).toFixed(4)} ${fromTokenBalance.symbol}`
+ : "Available: --"}
+
+ {isConnected && fromTokenBalance && (
+
+ )}
+
+
+ onFromAmountChange(e.target.value)}
+ className="text-white text-4xl font-light bg-transparent border-none outline-none w-full"
+ placeholder="0.00"
+ />
+
+
+ {fromAmount && fromToken
+ ? `โ$${(
+ parseFloat(fromAmount.replace(/,/g, "")) * 1000
+ ).toLocaleString()}`
+ : "โ$0"}
+
+
+
+
+
+ {/* To Section */}
+
+
+
+ To:
+ 0xe5d...85bde ๐ฆ
+
+
+ Token
+ Network
+
+
+
+
+
+
+
+ {toToken?.icon || toToken?.symbol?.[0] || "?"}
+
+
+
+ {toToken?.symbol || "Select Token"}
+
+
+
+
+
+ โ
+
+ Ethereum
+
+
+
+
+ You receive:
+
+
+
+ {isConnected && toTokenBalance
+ ? `Balance: ${parseFloat(toTokenBalance.formatted).toFixed(
+ 4
+ )} ${toTokenBalance.symbol}`
+ : "Balance: --"}
+
+
+
+
+
+ {isLoadingPrice ? (
+
+
+
+ Loading...
+
+ ) : priceError ? (
+ Error
+ ) : (
+ toAmount || "0.00"
+ )}
+
+ {toAmount && toToken
+ ? `โ$${(
+ parseFloat(toAmount.replace(/,/g, "")) * 1000
+ ).toLocaleString()}`
+ : "โ$0"}
+
+
+
+ {exchangeRate ||
+ (fromToken && toToken
+ ? `1 ${fromToken.symbol} = -- ${toToken.symbol}`
+ : "Select tokens to see rate")}
+
+ {exchangeRate && Live Rate}
+
+
+ {priceError ? (
+ {priceError}
+ ) : (
+ "Rate is for reference only. Updated in real-time"
+ )}
+
+
+ {/* Continue Button */}
+
+
+ {/* Floating celebration icons */}
+ {showCelebration &&
+ celebrations.map((celebration) => (
+
+ );
+};
diff --git a/src/components/swap/index.ts b/src/components/swap/index.ts
new file mode 100644
index 000000000..d2824bf37
--- /dev/null
+++ b/src/components/swap/index.ts
@@ -0,0 +1,10 @@
+export { ProgressSteps } from "./ProgressSteps";
+export { TabNavigation } from "./TabNavigation";
+export { TokenSelection } from "./TokenSelection";
+export { ReviewConfirm } from "./ReviewConfirm";
+export { Processing } from "./Processing";
+export { PizzaApproval } from "./PizzaApproval";
+export { Complete } from "./Complete";
+export { TransactionComplete } from "./TransactionComplete";
+export { NFTBadgeReward } from "./NFTBadgeReward";
+export { SwapInterface } from "./SwapInterface";
diff --git a/src/components/wallet/WalletConnect.tsx b/src/components/wallet/WalletConnect.tsx
new file mode 100644
index 000000000..aa065cd76
--- /dev/null
+++ b/src/components/wallet/WalletConnect.tsx
@@ -0,0 +1,113 @@
+'use client';
+
+import { ConnectButton } from '@rainbow-me/rainbowkit';
+
+export function WalletConnect() {
+ return (
+
+
+ ))}
+
+ {/* Main celebration header */}
+
+
+
+ {/* Success Animation */}
+
+
+ + {celebrationMessages[currentMessage]} +
++ Congratulations! You've completed Elton's Over-Engineered + Swap Protocol +
+
+
+
+
+
+ SWAP COMPLETED SUCCESSFULLY
+
+
+
+
+
+ {/* Swap Summary */}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ {/* Comedy Stats */}
+ {showStats && (
+
+
+
+
+
+ You Sent:
+
+
+
+ {fromAmount}
+ {fromToken?.symbol}
+
+
+ You Received:
+
+
+ {progress && (
+ <>
+
+
+ {toAmount}
+ {toToken?.symbol}
+
+
+ Transaction Hash:
+ {progress.transactionHash ? (
+
+ {formatTransactionHash(progress.transactionHash)}
+
+ ) : (
+ Processing...
+ )}
+
+
+ )}
+
+
+
+ Status:
+
+
+
+ Confirmed
+
+
+
+ )}
+
+ {/* Achievement Unlocked */}
+ {showStats && (
+ + Over-Engineering Statistics +
+
+
+
+
+
+ 4
+
+
+ Theatrical Steps Completed
+
+
+
+
+ 100%
+
+
+ Comedy Mission Success
+
+
+
+
+ โ
+
+
+ Unnecessary Complexity
+
+
+
+
+ 1
+
+
+ Pizza Consumed by Elton
+
+
+
+ + “Congratulations! You've successfully navigated the + most unnecessarily complex token swap in DeFi history. Your + patience with our theatrical delays has been rewarded!” - + Elton +
+
+
+ )}
+
+ {/* Action Buttons */}
+
+
+
+
+ + ACHIEVEMENT UNLOCKED! +
++ “Swap Survivor” +
++ You survived Elton's Over-Engineered Swap Protocol and lived + to tell the tale! +
+
+
+
+ {progress?.transactionHash && (
+
+ )}
+
+
+ {/* Bottom encouragement */}
+
+
+ + {showStats + ? "Ready for your NFT badge? Click above to proceed to the final step!" + : "Celebrating your successful swap..."} +
+
+ {(() => {
+ if (!connected) {
+ return (
+
+ );
+ }
+
+ if (chain.unsupported) {
+ return (
+
+ );
+ }
+
+ return (
+
+ );
+ }}
+
+
+
+
+
+ );
+ })()}
+