root/hoodquidity
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Hoodquidity: liquidity campaigns for Robinhood Chain stock token markets

Browse source 
Full build: Vite/React acid-terminal frontend (BEARER design system,
Panchang/Sentient/Fragment Mono, neon layer, palette audit script),
HoodquidityVaults Foundry contracts (single+dual deposits via Chainlink-style
feeds, hybrid exit, 10% platform fee, boost, Genesis LP), Reown AppKit wallet
connect with Robinhood Chain testnet (46630), live data from Dexscreener and
onchain reads, partner portal, design-sync setup for claude.ai/design.

Deploy: static via Forgejo Actions platform, BUILD_DIR=apps/web/dist (.env).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Денис Зефиров 2026-07-11 08:31:01 +04:00
commit dba2811447
1194 changed files with 206422 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

66
packages/contracts/README.md Normal file
View file

@ -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 <your_rpc_url> --private-key <your_private_key>
```
### Cast
```shell
$ cast <subcommand>
```
### Help
```shell
$ forge --help
$ anvil --help
$ cast --help
```

15
packages/contracts/foundry.toml Normal file
View file

@ -0,0 +1,15 @@
[profile.default]
src = "src"
out = "out"
libs = ["lib"]
solc = "0.8.26"
optimizer = true
optimizer_runs = 200
via_ir = true
remappings = [
"@openzeppelin/=lib/openzeppelin-contracts/",
"forge-std/=lib/forge-std/src/",
]
[rpc_endpoints]
arbitrum_sepolia = "https://sepolia-rollup.arbitrum.io/rpc"

1
packages/contracts/lib/forge-std/.gitattributes vendored Normal file
View file

@ -0,0 +1 @@
src/Vm.sol linguist-generated

1
packages/contracts/lib/forge-std/.github/CODEOWNERS vendored Normal file
View file

@ -0,0 +1 @@
* @danipopes @mattsse @grandizzy @onbjerg @0xrusowsky

15
packages/contracts/lib/forge-std/.github/dependabot.yml vendored Normal file
View file

@ -0,0 +1,15 @@
version: 2
updates:
- package-ecosystem: github-actions
directory: /
schedule:
interval: weekly
day: monday
time: "09:00"
timezone: UTC
cooldown:
default-days: 7
groups:
ci-weekly:
patterns:
- '*'

163
packages/contracts/lib/forge-std/.github/workflows/ci.yml vendored Normal file
View file

@ -0,0 +1,163 @@
name: CI
permissions: {}
on:
workflow_dispatch:
pull_request:
push:
branches:
- master
env:
SOLC_MINIMUM: "0.8.13"
SOLC_LATEST: "0.8.35"
SOLC_PRERELEASE: ""
jobs:
build-matrix:
runs-on: ubuntu-latest
timeout-minutes: 5
permissions:
contents: read
outputs:
matrix: ${{ steps.generate.outputs.matrix }}
steps:
- id: generate
run: |
MINIMUM="${{ env.SOLC_MINIMUM }}"
LATEST="${{ env.SOLC_LATEST }}"
PRERELEASE="${{ env.SOLC_PRERELEASE }}"
matrix='{"include":['
for toolchain in stable nightly; do
for flags in \
"" \
"--via-ir" \
"--use solc:${LATEST}" \
"--use solc:${LATEST} --via-ir" \
"--use solc:${MINIMUM}" \
"--use solc:${MINIMUM} --via-ir"
do
matrix+='{"toolchain":"'"$toolchain"'","flags":"'"$flags"'","prerelease":false},'
done
done
# prerelease (nightly only, svm-rs is not up to date on stable)
if [ -n "$PRERELEASE" ]; then
for flags in \
"--use solc:${PRERELEASE}" \
"--use solc:${PRERELEASE} --via-ir"
do
matrix+='{"toolchain":"nightly","flags":"'"$flags"'","prerelease":true},'
done
fi
matrix="${matrix%,}]}"
echo "matrix=$matrix" >> "$GITHUB_OUTPUT"
build:
needs: build-matrix
name: build +${{ matrix.toolchain }} ${{ matrix.flags }}
runs-on: ubuntu-latest
timeout-minutes: 10
permissions:
contents: read
strategy:
fail-fast: false
matrix: ${{ fromJSON(needs.build-matrix.outputs.matrix) }}
steps:
- uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
with:
persist-credentials: false
- uses: foundry-rs/foundry-toolchain@c7450ba673e133f5ee30098b3b54f444d3a2ca2d # v1.8.0
with:
version: ${{ matrix.toolchain }}
- run: forge --version
# 3805: "This is a pre-release compiler version, please do not use it in production."
- run: forge build -vvvvv --skip test --deny warnings ${{ matrix.prerelease && '--ignored-error-codes 3805' || '' }} ${{ matrix.flags }} --contracts 'test/compilation/*'
test:
runs-on: ubuntu-latest
timeout-minutes: 10
permissions:
contents: read
strategy:
fail-fast: false
matrix:
toolchain: [stable, nightly]
steps:
- uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
with:
persist-credentials: false
- uses: foundry-rs/foundry-toolchain@c7450ba673e133f5ee30098b3b54f444d3a2ca2d # v1.8.0
with:
version: ${{ matrix.toolchain }}
- run: forge --version
- run: forge test -vvv
fmt:
runs-on: ubuntu-latest
timeout-minutes: 10
permissions:
contents: read
steps:
- uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
with:
persist-credentials: false
- uses: foundry-rs/foundry-toolchain@c7450ba673e133f5ee30098b3b54f444d3a2ca2d # v1.8.0
- run: forge --version
- run: forge fmt --check
typos:
runs-on: ubuntu-latest
timeout-minutes: 10
permissions:
contents: read
steps:
- uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
with:
persist-credentials: false
- uses: crate-ci/typos@5374cbf686e897b15713110e233094e2874de7ef # v1.46.1
codeql:
name: Analyze (${{ matrix.language }})
runs-on: ubuntu-latest
permissions:
security-events: write
actions: read
contents: read
strategy:
fail-fast: false
matrix:
include:
- language: actions
build-mode: none
steps:
- name: Checkout repository
uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
with:
persist-credentials: false
- name: Initialize CodeQL
uses: github/codeql-action/init@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
with:
languages: ${{ matrix.language }}
build-mode: ${{ matrix.build-mode }}
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@8aad20d150bbac5944a9f9d289da16a4b0d87c1e # v4.36.2
with:
category: "/language:${{matrix.language}}"
ci-success:
runs-on: ubuntu-latest
if: always()
needs:
- build-matrix
- build
- test
- fmt
- typos
- codeql
timeout-minutes: 10
steps:
- name: Decide whether the needed jobs succeeded or failed
uses: re-actors/alls-green@05ac9388f0aebcb5727afa17fcccfecd6f8ec5fe # release/v1
with:
jobs: ${{ toJSON(needs) }}

36
packages/contracts/lib/forge-std/.github/workflows/sync.yml vendored Normal file
View file

@ -0,0 +1,36 @@
name: Sync Release Branch
permissions: {}
on:
release:
types:
- created
jobs:
sync-release-branch:
runs-on: ubuntu-latest
permissions:
contents: write
if: startsWith(github.event.release.tag_name, 'v1')
steps:
- name: Check out the repo
uses: actions/checkout@9c091bb21b7c1c1d1991bb908d89e4e9dddfe3e0 # v7.0.0
with:
persist-credentials: true
fetch-depth: 0
ref: v1
# The email is derived from the bots user id,
# found here: https://api.github.com/users/github-actions%5Bbot%5D
- name: Configure Git
run: |
git config user.name github-actions[bot]
git config user.email 41898282+github-actions[bot]@users.noreply.github.com
- name: Sync Release Branch
run: |
git fetch --tags
git checkout v1
git reset --hard ${GITHUB_REF}
git push --force

4
packages/contracts/lib/forge-std/.gitignore vendored Normal file
View file

@ -0,0 +1,4 @@
cache/
out/
.vscode
.idea

193
packages/contracts/lib/forge-std/CONTRIBUTING.md Normal file
View file

@ -0,0 +1,193 @@
## Contributing to Foundry
Thanks for your interest in improving Foundry!
There are multiple opportunities to contribute at any level. It doesn't matter if you are just getting started with Rust or are the most weathered expert, we can use your help.
This document will help you get started. **Do not let the document intimidate you**.
It should be considered as a guide to help you navigate the process.
The [dev Telegram][dev-tg] is available for any concerns you may have that are not covered in this guide.
### Code of Conduct
The Foundry project adheres to the [Rust Code of Conduct][rust-coc]. This code of conduct describes the _minimum_ behavior expected from all contributors.
Instances of violations of the Code of Conduct can be reported by contacting the team at [me@gakonst.com](mailto:me@gakonst.com).
### Ways to contribute
There are fundamentally four ways an individual can contribute:
1. **By opening an issue:** For example, if you believe that you have uncovered a bug
in Foundry, creating a new issue in the issue tracker is the way to report it.
2. **By adding context:** Providing additional context to existing issues,
such as screenshots and code snippets, which help resolve issues.
3. **By resolving issues:** Typically this is done in the form of either
demonstrating that the issue reported is not a problem after all, or more often,
by opening a pull request that fixes the underlying problem, in a concrete and
reviewable manner.
**Anybody can participate in any stage of contribution**. We urge you to participate in the discussion
around bugs and participate in reviewing PRs.
### Contributions Related to Spelling and Grammar
At this time, we will not be accepting contributions that only fix spelling or grammatical errors in documentation, code or
elsewhere.
### Asking for help
If you have reviewed existing documentation and still have questions, or you are having problems, you can get help in the following ways:
- **Asking in the support Telegram:** The [Foundry Support Telegram][support-tg] is a fast and easy way to ask questions.
- **Opening a discussion:** This repository comes with a discussions board where you can also ask for help. Click the "Discussions" tab at the top.
As Foundry is still in heavy development, the documentation can be a bit scattered.
The [Foundry Book][foundry-book] is our current best-effort attempt at keeping up-to-date information.
### Submitting a bug report
When filing a new bug report in the issue tracker, you will be presented with a basic form to fill out.
If you believe that you have uncovered a bug, please fill out the form to the best of your ability. Do not worry if you cannot answer every detail; just fill in what you can. Contributors will ask follow-up questions if something is unclear.
The most important pieces of information we need in a bug report are:
- The Foundry version you are on (and that it is up to date)
- The platform you are on (Windows, macOS, an M1 Mac or Linux)
- Code snippets if this is happening in relation to testing or building code
- Concrete steps to reproduce the bug
In order to rule out the possibility of the bug being in your project, the code snippets should be as minimal
as possible. It is better if you can reproduce the bug with a small snippet as opposed to an entire project!
See [this guide][mcve] on how to create a minimal, complete, and verifiable example.
### Submitting a feature request
When adding a feature request in the issue tracker, you will be presented with a basic form to fill out.
Please include as detailed of an explanation as possible of the feature you would like, adding additional context if necessary.
If you have examples of other tools that have the feature you are requesting, please include them as well.
### Resolving an issue
Pull requests are the way concrete changes are made to the code, documentation, and dependencies of Foundry.
Even minor pull requests, such as those fixing wording, are greatly appreciated. Before making a large change, it is usually
a good idea to first open an issue describing the change to solicit feedback and guidance. This will increase
the likelihood of the PR getting merged.
Please make sure that the following commands pass if you have changed the code:
```sh
forge fmt --check
forge test -vvv
```
To make sure your changes are compatible with all compiler version targets, run the following commands:
```sh
forge build --skip test --use solc:0.6.2
forge build --skip test --use solc:0.6.12
forge build --skip test --use solc:0.7.0
forge build --skip test --use solc:0.7.6
forge build --skip test --use solc:0.8.0
```
The CI will also ensure that the code is formatted correctly and that the tests are passing across all compiler version targets.
#### Adding cheatcodes
Please follow the guide outlined in the [cheatcodes](https://github.com/foundry-rs/foundry/blob/master/docs/dev/cheatcodes.md#adding-a-new-cheatcode) documentation of Foundry.
When making modifications to the native cheatcodes or adding new ones, please make sure to run [`./scripts/vm.py`](./scripts/vm.py) to update the cheatcodes in the [`src/Vm.sol`](./src/Vm.sol) file.
By default the script will automatically generate the cheatcodes from the [`cheatcodes.json`](https://raw.githubusercontent.com/foundry-rs/foundry/master/crates/cheatcodes/assets/cheatcodes.json) file but alternatively you can provide a path to a JSON file containing the Vm interface, as generated by Foundry, with the `--from` flag.
```sh
./scripts/vm.py --from path/to/cheatcodes.json
```
It is possible that the resulting [`src/Vm.sol`](./src/Vm.sol) file will have some changes that are not directly related to your changes, this is not a problem.
#### Commits
It is a recommended best practice to keep your changes as logically grouped as possible within individual commits. There is no limit to the number of commits any single pull request may have, and many contributors find it easier to review changes that are split across multiple commits.
That said, if you have a number of commits that are "checkpoints" and don't represent a single logical change, please squash those together.
#### Opening the pull request
From within GitHub, opening a new pull request will present you with a template that should be filled out. Please try your best at filling out the details, but feel free to skip parts if you're not sure what to put.
#### Discuss and update
You will probably get feedback or requests for changes to your pull request.
This is a big part of the submission process, so don't be discouraged! Some contributors may sign off on the pull request right away, others may have more detailed comments or feedback.
This is a necessary part of the process in order to evaluate whether the changes are correct and necessary.
**Any community member can review a PR, so you might get conflicting feedback**.
Keep an eye out for comments from code owners to provide guidance on conflicting feedback.
#### Reviewing pull requests
**Any Foundry community member is welcome to review any pull request**.
All contributors who choose to review and provide feedback on pull requests have a responsibility to both the project and individual making the contribution. Reviews and feedback must be helpful, insightful, and geared towards improving the contribution as opposed to simply blocking it. If there are reasons why you feel the PR should not be merged, explain what those are. Do not expect to be able to block a PR from advancing simply because you say "no" without giving an explanation. Be open to having your mind changed. Be open to working _with_ the contributor to make the pull request better.
Reviews that are dismissive or disrespectful of the contributor or any other reviewers are strictly counter to the Code of Conduct.
When reviewing a pull request, the primary goals are for the codebase to improve and for the person submitting the request to succeed. **Even if a pull request is not merged, the submitter should come away from the experience feeling like their effort was appreciated**. Every PR from a new contributor is an opportunity to grow the community.
##### Review a bit at a time
Do not overwhelm new contributors.
It is tempting to micro-optimize and make everything about relative performance, perfect grammar, or exact style matches. Do not succumb to that temptation.
Focus first on the most significant aspects of the change:
1. Does this change make sense for Foundry?
2. Does this change make Foundry better, even if only incrementally?
3. Are there clear bugs or larger scale issues that need attending?
4. Are the commit messages readable and correct? If it contains a breaking change, is it clear enough?
Note that only **incremental** improvement is needed to land a PR. This means that the PR does not need to be perfect, only better than the status quo. Follow-up PRs may be opened to continue iterating.
When changes are necessary, _request_ them, do not _demand_ them, and **do not assume that the submitter already knows how to add a test or run a benchmark**.
Specific performance optimization techniques, coding styles and conventions change over time. The first impression you give to a new contributor never does.
Nits (requests for small changes that are not essential) are fine, but try to avoid stalling the pull request. Most nits can typically be fixed by the Foundry maintainers merging the pull request, but they can also be an opportunity for the contributor to learn a bit more about the project.
It is always good to clearly indicate nits when you comment, e.g.: `Nit: change foo() to bar(). But this is not blocking`.
If your comments were addressed but were not folded after new commits, or if they proved to be mistaken, please, [hide them][hiding-a-comment] with the appropriate reason to keep the conversation flow concise and relevant.
##### Be aware of the person behind the code
Be aware that _how_ you communicate requests and reviews in your feedback can have a significant impact on the success of the pull request. Yes, we may merge a particular change that makes Foundry better, but the individual might just not want to have anything to do with Foundry ever again. The goal is not just having good code.
##### Abandoned or stale pull requests
If a pull request appears to be abandoned or stalled, it is polite to first check with the contributor to see if they intend to continue the work before checking if they would mind if you took it over (especially if it just has nits left). When doing so, it is courteous to give the original contributor credit for the work they started, either by preserving their name and e-mail address in the commit log, or by using the `Author: ` or `Co-authored-by: ` metadata tag in the commits.
_Adapted from the [ethers-rs contributing guide](https://github.com/gakonst/ethers-rs/blob/master/CONTRIBUTING.md)_.
### Releasing
Releases are automatically done by the release workflow when a tag is pushed, however, these steps still need to be taken:
1. Ensure that the versions in the relevant `Cargo.toml` files are up-to-date.
2. Update documentation links
3. Perform a final audit for breaking changes.
[rust-coc]: https://github.com/rust-lang/rust/blob/master/CODE_OF_CONDUCT.md
[dev-tg]: https://t.me/foundry_rs
[foundry-book]: https://github.com/foundry-rs/foundry-book
[support-tg]: https://t.me/foundry_support
[mcve]: https://stackoverflow.com/help/mcve
[hiding-a-comment]: https://help.github.com/articles/managing-disruptive-comments/#hiding-a-comment

203
packages/contracts/lib/forge-std/LICENSE-APACHE Normal file
View file

@ -0,0 +1,203 @@
Copyright Contributors to Forge Standard Library
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

25
packages/contracts/lib/forge-std/LICENSE-MIT Normal file
View file

@ -0,0 +1,25 @@
Copyright Contributors to Forge Standard Library
Permission is hereby granted, free of charge, to any
person obtaining a copy of this software and associated
documentation files (the "Software"), to deal in the
Software without restriction, including without
limitation the rights to use, copy, modify, merge,
publish, distribute, sublicense, and/or sell copies of
the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following
conditions:
The above copyright notice and this permission notice
shall be included in all copies or substantial portions
of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
IN CONNECTION WITH THE SOFTWARE O THE USE OR OTHER
DEALINGS IN THE SOFTWARE.R

314
packages/contracts/lib/forge-std/README.md Normal file
View file

@ -0,0 +1,314 @@
# Forge Standard Library • [![CI status](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml/badge.svg)](https://github.com/foundry-rs/forge-std/actions/workflows/ci.yml)
Forge Standard Library is a collection of helpful contracts and libraries for use with [Forge and Foundry](https://github.com/foundry-rs/foundry). It leverages Forge's cheatcodes to make writing tests easier and faster, while improving the UX of cheatcodes.
**Learn how to use Forge-Std with the [📖 Foundry Book (Forge-Std Guide)](https://getfoundry.sh/reference/forge-std/overview/).**
## Install
```bash
forge install foundry-rs/forge-std
```
## Contracts
### stdError
This is a helper contract for errors and reverts. In Forge, this contract is particularly helpful for the `expectRevert` cheatcode, as it provides all compiler built-in errors.
See the contract itself for all error codes.
#### Example usage
```solidity
import "forge-std/Test.sol";
contract TestContract is Test {
ErrorsTest test;
function setUp() public {
test = new ErrorsTest();
}
function testExpectArithmetic() public {
vm.expectRevert(stdError.arithmeticError);
test.arithmeticError(10);
}
}
contract ErrorsTest {
function arithmeticError(uint256 a) public {
a = a - 100;
}
}
```
### stdStorage
This is a rather large contract due to all of the overloading to make the UX decent. Primarily, it is a wrapper around the `record` and `accesses` cheatcodes. It can _always_ find and write the storage slot(s) associated with a particular variable without knowing the storage layout. By default, writing to packed storage variables is not supported and will throw an error. However, you can enable packed slot support by calling `enable_packed_slots()` before using `find()` or `checked_write()`.
This works by recording all `SLOAD`s and `SSTORE`s during a function call. If there is a single slot read or written to, it immediately returns the slot. Otherwise, behind the scenes, we iterate through and check each one (assuming the user passed in a `depth` parameter). If the variable is a struct, you can pass in a `depth` parameter which is basically the field depth.
I.e.:
```solidity
struct T {
// depth 0
uint256 a;
// depth 1
uint256 b;
}
```
#### Example usage
```solidity
import "forge-std/Test.sol";
contract TestContract is Test {
using stdStorage for StdStorage;
Storage test;
function setUp() public {
test = new Storage();
}
function testFindExists() public {
// Let's say we want to find the slot for the public
// variable `exists`. We just pass in the function selector
// to the `find` command
uint256 slot = stdstore.target(address(test)).sig("exists()").find();
assertEq(slot, 0);
}
function testWriteExists() public {
// Let's say we want to write to the slot for the public
// variable `exists`. We just pass in the function selector
// to the `checked_write` command
stdstore.target(address(test)).sig("exists()").checked_write(100);
assertEq(test.exists(), 100);
}
// It supports arbitrary storage layouts, like assembly-based storage locations
function testFindHidden() public {
// `hidden` is a random hash of bytes; iterating through slots would
// not find it. Our mechanism does
// Also, you can use the selector instead of a string
uint256 slot = stdstore.target(address(test)).sig(test.hidden.selector).find();
assertEq(slot, uint256(keccak256("my.random.var")));
}
// If targeting a mapping, you have to pass in the keys necessary to perform the find
// i.e.:
function testFindMapping() public {
uint256 slot = stdstore
.target(address(test))
.sig(test.map_addr.selector)
.with_key(address(this))
.find();
// in the `Storage` constructor, we wrote that this address' value was 1 in the map
// so when we load the slot, we expect it to be 1
assertEq(uint(vm.load(address(test), bytes32(slot))), 1);
}
// If the target is a struct, you can specify the field depth:
function testFindStruct() public {
// NOTE: see the depth parameter - 0 means 0th field, 1 means 1st field, etc.
uint256 slot_for_a_field = stdstore
.target(address(test))
.sig(test.basicStruct.selector)
.depth(0)
.find();
uint256 slot_for_b_field = stdstore
.target(address(test))
.sig(test.basicStruct.selector)
.depth(1)
.find();
assertEq(uint(vm.load(address(test), bytes32(slot_for_a_field))), 1);
assertEq(uint(vm.load(address(test), bytes32(slot_for_b_field))), 2);
}
}
// A complex storage contract
contract Storage {
struct UnpackedStruct {
uint256 a;
uint256 b;
}
constructor() {
map_addr[msg.sender] = 1;
}
uint256 public exists = 1;
mapping(address => uint256) public map_addr;
// mapping(address => Packed) public map_packed;
mapping(address => UnpackedStruct) public map_struct;
mapping(address => mapping(address => uint256)) public deep_map;
mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct;
UnpackedStruct public basicStruct = UnpackedStruct({
a: 1,
b: 2
});
function hidden() public view returns (bytes32 t) {
// an extremely hidden storage slot
bytes32 slot = keccak256("my.random.var");
assembly {
t := sload(slot)
}
}
}
```
### stdCheats
This is a wrapper around miscellaneous cheatcodes that need wrappers to be more dev-friendly. It includes functions for pranking, dealing with ETH and tokens, deploying contracts, creating test addresses, time manipulation, and fuzzing helpers. In general, users may expect ETH to be put into an address with `prank`, but this is not the case for safety reasons. Explicitly, this `hoax` function should only be used for addresses that have expected balances as it will get overwritten. If an address already has ETH, you should just use `prank`. If you want to change that balance explicitly, just use `deal`. If you want to do both, `hoax` is also right for you.
#### Example usage:
```solidity
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.0;
import "forge-std/Test.sol";
// Inherit the stdCheats
contract StdCheatsTest is Test {
Bar test;
function setUp() public {
test = new Bar();
}
function testHoax() public {
// we call `hoax`, which gives the target address
// eth and then calls `prank`
hoax(address(1337));
test.bar{value: 100}(address(1337));
// overloaded to allow you to specify how much eth to
// initialize the address with
hoax(address(1337), 1);
test.bar{value: 1}(address(1337));
}
function testStartHoax() public {
// we call `startHoax`, which gives the target address
// eth and then calls `startPrank`
//
// it is also overloaded so that you can specify an eth amount
startHoax(address(1337));
test.bar{value: 100}(address(1337));
test.bar{value: 100}(address(1337));
vm.stopPrank();
test.bar(address(this));
}
}
contract Bar {
function bar(address expectedSender) public payable {
require(msg.sender == expectedSender, "!prank");
}
}
```
### Std Assertions
Provides comprehensive assertion functions for testing, including equality checks (assertEq, assertNotEq), comparisons (assertLt, assertGt, assertLe, assertGe), approximate equality (assertApproxEqAbs, assertApproxEqRel), and boolean assertions (assertTrue, assertFalse). All assertions support multiple data types and optional custom error messages.
### StdConfig
This is a contract that parses a TOML configuration file and loads its variables into storage, automatically casting them on deployment. It assumes a TOML structure where top-level keys represent chain IDs or aliases. Under each chain key, variables are organized by type in separate sub-tables like `[<chain>.<type>]`, where type must be: `bool`, `address`, `bytes32`, `uint`, `int`, `string`, or `bytes`.
#### Example usage
```solidity
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.13;
import "forge-std/Script.sol";
import "forge-std/StdConfig.sol";
contract MyScript is Script {
StdConfig config;
function run() public {
// Load config (set writeToFile=true only in scripts to persist changes)
config = new StdConfig("config.toml", false);
// Get values for the current chain
uint256 myNumber = config.get("important_number").toUint256();
address weth = config.get("weth").toAddress();
address[] memory admins = config.get("whitelisted_admins").toAddressArray();
// Get values for a specific chain
bool isLive = config.get(1, "is_live").toBool();
// Check if a key exists
if (config.exists("optional_param")) {
// ...
}
// Get RPC URL for current or specific chain
string memory rpc = config.getRpcUrl();
string memory mainnetRpc = config.getRpcUrl(1);
// Get all configured chain IDs
uint256[] memory chainIds = config.getChainIds();
}
}
```
See the contract itself for supported TOML format and all available methods.
### `console.log`
Usage follows the same format as [Hardhat](https://hardhat.org/hardhat-network/reference/#console-log).
It's recommended to use `console2.sol` as shown below, as this will show the decoded logs in Forge traces.
```solidity
// import it indirectly via Test.sol
import "forge-std/Test.sol";
// or directly import it
import "forge-std/console2.sol";
...
console2.log(someValue);
```
If you need compatibility with Hardhat, you must use the standard `console.sol` instead.
Due to a bug in `console.sol`, logs that use `uint256` or `int256` types will not be properly decoded in Forge traces.
```solidity
// import it indirectly via Test.sol
import "forge-std/Test.sol";
// or directly import it
import "forge-std/console.sol";
...
console.log(someValue);
```
## Contributing
See our [contributing guidelines](./CONTRIBUTING.md).
## Getting Help
First, see if the answer to your question can be found in [book](https://getfoundry.sh/).
If the answer is not there:
- Join the [support Telegram](https://t.me/foundry_support) to get help, or
- Open a [discussion](https://github.com/foundry-rs/foundry/discussions/new/choose) with your question, or
- Open an issue with [the bug](https://github.com/foundry-rs/foundry/issues/new/choose)
If you want to contribute, or follow along with contributor discussion, you can use our [main telegram](https://t.me/foundry_rs) to chat with us about the development of Foundry!
## License
Forge Standard Library is offered under either [MIT](LICENSE-MIT) or [Apache 2.0](LICENSE-APACHE) license.

12
packages/contracts/lib/forge-std/RELEASE_CHECKLIST.md Normal file
View file

@ -0,0 +1,12 @@
# Release checklist
This checklist is meant to be used as a guide for the `forge-std` release process.
## Steps
- [ ] Update the version number in `package.json`
- [ ] Open and merge a PR with the version bump
- [ ] Tag the merged commit with the version number: `git tag v<X.Y.Z>`
- [ ] Push the tag to the repository: `git push --tags`
- [ ] Create a new GitHub release with the automatically generated changelog and the name set to `v<X.Y.Z>`
- [ ] Add `## Featured Changes` section to the top of the release notes

18
packages/contracts/lib/forge-std/foundry.toml Normal file
View file

@ -0,0 +1,18 @@
[profile.default]
fs_permissions = [{ access = "read-write", path = "./" }]
optimizer = true
optimizer_runs = 200
# A list of solidity error codes to ignore.
# 3860 = init-code-size
ignored_error_codes = [3860]
[rpc_endpoints]
# The RPC URLs are modified versions of the default for testing initialization.
mainnet = "https://ethereum.reth.rs/rpc"
optimism_sepolia = "https://sepolia.optimism.io/" # Adds a trailing slash.
arbitrum_one_sepolia = "https://sepolia-rollup.arbitrum.io/rpc/" # Adds a trailing slash.
needs_undefined_env_var = "${UNDEFINED_RPC_URL_PLACEHOLDER}"
[lint]
lint_on_build = false

16
packages/contracts/lib/forge-std/package.json Normal file
View file

@ -0,0 +1,16 @@
{
"name": "forge-std",
"version": "1.16.2",
"description": "Forge Standard Library is a collection of helpful contracts and libraries for use with Forge and Foundry.",
"homepage": "https://book.getfoundry.sh/forge/forge-std",
"bugs": "https://github.com/foundry-rs/forge-std/issues",
"license": "(Apache-2.0 OR MIT)",
"author": "Contributors to Forge Standard Library",
"files": [
"src/**/*"
],
"repository": {
"type": "git",
"url": "https://github.com/foundry-rs/forge-std.git"
}
}

636
packages/contracts/lib/forge-std/scripts/vm.py Executable file
View file

@ -0,0 +1,636 @@
#!/usr/bin/env python3
import argparse
import copy
import json
import re
import subprocess
from enum import Enum as PyEnum
from pathlib import Path
from typing import Callable, Optional, Union
from urllib import request
VoidFn = Callable[[], None]
CHEATCODES_JSON_URL = "https://raw.githubusercontent.com/foundry-rs/foundry/master/crates/cheatcodes/assets/cheatcodes.json"
OUT_PATH = "src/Vm.sol"
VM_SAFE_DOC = """\
/// The `VmSafe` interface does not allow manipulation of the EVM state or other actions that may
/// result in Script simulations differing from on-chain execution. It is recommended to only use
/// these cheats in scripts.
"""
VM_DOC = """\
/// The `Vm` interface does allow manipulation of the EVM state. These are all intended to be used
/// in tests, but it is not recommended to use these cheats in scripts.
"""
def main():
parser = argparse.ArgumentParser(
description="Generate Vm.sol based on the cheatcodes json created by Foundry")
parser.add_argument(
"--from",
metavar="PATH",
dest="path",
required=False,
help="path to a json file containing the Vm interface, as generated by Foundry")
args = parser.parse_args()
json_str = request.urlopen(CHEATCODES_JSON_URL).read().decode("utf-8") if args.path is None else Path(args.path).read_text()
contract = Cheatcodes.from_json(json_str)
ccs = contract.cheatcodes
ccs = list(filter(lambda cc: cc.status not in ["experimental", "internal"], ccs))
ccs.sort(key=lambda cc: cc.func.id)
safe = list(filter(lambda cc: cc.safety == "safe", ccs))
safe.sort(key=CmpCheatcode)
unsafe = list(filter(lambda cc: cc.safety == "unsafe", ccs))
unsafe.sort(key=CmpCheatcode)
assert len(safe) + len(unsafe) == len(ccs)
prefix_with_group_headers(safe)
prefix_with_group_headers(unsafe)
out = ""
out += "// Automatically @generated by scripts/vm.py. Do not modify manually.\n\n"
pp = CheatcodesPrinter(
spdx_identifier="MIT OR Apache-2.0",
solidity_requirement=">=0.8.13 <0.9.0",
)
pp.p_prelude()
pp.prelude = False
out += pp.finish()
out += "\n\n"
out += VM_SAFE_DOC
vm_safe = Cheatcodes(
# TODO: Custom errors were introduced in 0.8.4
errors=[], # contract.errors
events=contract.events,
enums=contract.enums,
structs=contract.structs,
cheatcodes=safe,
)
pp.p_contract(vm_safe, "VmSafe")
out += pp.finish()
out += "\n\n"
out += VM_DOC
vm_unsafe = Cheatcodes(
errors=[],
events=[],
enums=[],
structs=[],
cheatcodes=unsafe,
)
pp.p_contract(vm_unsafe, "Vm", "VmSafe")
out += pp.finish()
# Compatibility with <0.8.0
def memory_to_calldata(m: re.Match) -> str:
return " calldata " + m.group(1)
out = re.sub(r" memory (.*returns)", memory_to_calldata, out)
with open(OUT_PATH, "w") as f:
f.write(out)
forge_fmt = ["forge", "fmt", OUT_PATH]
res = subprocess.run(forge_fmt)
assert res.returncode == 0, f"command failed: {forge_fmt}"
print(f"Wrote to {OUT_PATH}")
class CmpCheatcode:
cheatcode: "Cheatcode"
def __init__(self, cheatcode: "Cheatcode"):
self.cheatcode = cheatcode
def __lt__(self, other: "CmpCheatcode") -> bool:
return cmp_cheatcode(self.cheatcode, other.cheatcode) < 0
def __eq__(self, other: "CmpCheatcode") -> bool:
return cmp_cheatcode(self.cheatcode, other.cheatcode) == 0
def __gt__(self, other: "CmpCheatcode") -> bool:
return cmp_cheatcode(self.cheatcode, other.cheatcode) > 0
def cmp_cheatcode(a: "Cheatcode", b: "Cheatcode") -> int:
if a.group != b.group:
return -1 if a.group < b.group else 1
if a.status != b.status:
return -1 if a.status < b.status else 1
if a.safety != b.safety:
return -1 if a.safety < b.safety else 1
if a.func.id != b.func.id:
return -1 if a.func.id < b.func.id else 1
return 0
# HACK: A way to add group header comments without having to modify printer code
def prefix_with_group_headers(cheats: list["Cheatcode"]):
s = set()
for i, cheat in enumerate(cheats):
if cheat.group in s:
continue
s.add(cheat.group)
c = copy.deepcopy(cheat)
c.func.description = ""
c.func.declaration = f"// ======== {group(c.group)} ========"
cheats.insert(i, c)
return cheats
def group(s: str) -> str:
if s == "evm":
return "EVM"
if s == "json":
return "JSON"
return s[0].upper() + s[1:]
class Visibility(PyEnum):
EXTERNAL: str = "external"
PUBLIC: str = "public"
INTERNAL: str = "internal"
PRIVATE: str = "private"
def __str__(self):
return self.value
class Mutability(PyEnum):
PURE: str = "pure"
VIEW: str = "view"
NONE: str = ""
def __str__(self):
return self.value
class Function:
id: str
description: str
declaration: str
visibility: Visibility
mutability: Mutability
signature: str
selector: str
selector_bytes: bytes
def __init__(
self,
id: str,
description: str,
declaration: str,
visibility: Visibility,
mutability: Mutability,
signature: str,
selector: str,
selector_bytes: bytes,
):
self.id = id
self.description = description
self.declaration = declaration
self.visibility = visibility
self.mutability = mutability
self.signature = signature
self.selector = selector
self.selector_bytes = selector_bytes
@staticmethod
def from_dict(d: dict) -> "Function":
return Function(
d["id"],
d["description"],
d["declaration"],
Visibility(d["visibility"]),
Mutability(d["mutability"]),
d["signature"],
d["selector"],
bytes(d["selectorBytes"]),
)
class Cheatcode:
func: Function
group: str
status: str
safety: str
def __init__(self, func: Function, group: str, status: str, safety: str):
self.func = func
self.group = group
self.status = status
self.safety = safety
@staticmethod
def from_dict(d: dict) -> "Cheatcode":
return Cheatcode(
Function.from_dict(d["func"]),
str(d["group"]),
str(d["status"]),
str(d["safety"]),
)
class Error:
name: str
description: str
declaration: str
def __init__(self, name: str, description: str, declaration: str):
self.name = name
self.description = description
self.declaration = declaration
@staticmethod
def from_dict(d: dict) -> "Error":
return Error(**d)
class Event:
name: str
description: str
declaration: str
def __init__(self, name: str, description: str, declaration: str):
self.name = name
self.description = description
self.declaration = declaration
@staticmethod
def from_dict(d: dict) -> "Event":
return Event(**d)
class EnumVariant:
name: str
description: str
def __init__(self, name: str, description: str):
self.name = name
self.description = description
class Enum:
name: str
description: str
variants: list[EnumVariant]
def __init__(self, name: str, description: str, variants: list[EnumVariant]):
self.name = name
self.description = description
self.variants = variants
@staticmethod
def from_dict(d: dict) -> "Enum":
return Enum(
d["name"],
d["description"],
list(map(lambda v: EnumVariant(**v), d["variants"])),
)
class StructField:
name: str
ty: str
description: str
def __init__(self, name: str, ty: str, description: str):
self.name = name
self.ty = ty
self.description = description
class Struct:
name: str
description: str
fields: list[StructField]
def __init__(self, name: str, description: str, fields: list[StructField]):
self.name = name
self.description = description
self.fields = fields
@staticmethod
def from_dict(d: dict) -> "Struct":
return Struct(
d["name"],
d["description"],
list(map(lambda f: StructField(**f), d["fields"])),
)
class Cheatcodes:
errors: list[Error]
events: list[Event]
enums: list[Enum]
structs: list[Struct]
cheatcodes: list[Cheatcode]
def __init__(
self,
errors: list[Error],
events: list[Event],
enums: list[Enum],
structs: list[Struct],
cheatcodes: list[Cheatcode],
):
self.errors = errors
self.events = events
self.enums = enums
self.structs = structs
self.cheatcodes = cheatcodes
@staticmethod
def from_dict(d: dict) -> "Cheatcodes":
return Cheatcodes(
errors=[Error.from_dict(e) for e in d["errors"]],
events=[Event.from_dict(e) for e in d["events"]],
enums=[Enum.from_dict(e) for e in d["enums"]],
structs=[Struct.from_dict(e) for e in d["structs"]],
cheatcodes=[Cheatcode.from_dict(e) for e in d["cheatcodes"]],
)
@staticmethod
def from_json(s) -> "Cheatcodes":
return Cheatcodes.from_dict(json.loads(s))
@staticmethod
def from_json_file(file_path: str) -> "Cheatcodes":
with open(file_path, "r") as f:
return Cheatcodes.from_dict(json.load(f))
class Item(PyEnum):
ERROR: str = "error"
EVENT: str = "event"
ENUM: str = "enum"
STRUCT: str = "struct"
FUNCTION: str = "function"
class ItemOrder:
_list: list[Item]
def __init__(self, list: list[Item]) -> None:
assert len(list) <= len(Item), "list must not contain more items than Item"
assert len(list) == len(set(list)), "list must not contain duplicates"
self._list = list
pass
def get_list(self) -> list[Item]:
return self._list
@staticmethod
def default() -> "ItemOrder":
return ItemOrder(
[
Item.ERROR,
Item.EVENT,
Item.ENUM,
Item.STRUCT,
Item.FUNCTION,
]
)
class CheatcodesPrinter:
buffer: str
prelude: bool
spdx_identifier: str
solidity_requirement: str
block_doc_style: bool
indent_level: int
_indent_str: str
nl_str: str
items_order: ItemOrder
def __init__(
self,
buffer: str = "",
prelude: bool = True,
spdx_identifier: str = "UNLICENSED",
solidity_requirement: str = "",
block_doc_style: bool = False,
indent_level: int = 0,
indent_with: Union[int, str] = 4,
nl_str: str = "\n",
items_order: ItemOrder = ItemOrder.default(),
):
self.prelude = prelude
self.spdx_identifier = spdx_identifier
self.solidity_requirement = solidity_requirement
self.block_doc_style = block_doc_style
self.buffer = buffer
self.indent_level = indent_level
self.nl_str = nl_str
if isinstance(indent_with, int):
assert indent_with >= 0
self._indent_str = " " * indent_with
elif isinstance(indent_with, str):
self._indent_str = indent_with
else:
assert False, "indent_with must be int or str"
self.items_order = items_order
def finish(self) -> str:
ret = self.buffer.rstrip()
self.buffer = ""
return ret
def p_contract(self, contract: Cheatcodes, name: str, inherits: str = ""):
if self.prelude:
self.p_prelude(contract)
self._p_str("interface ")
name = name.strip()
if name != "":
self._p_str(name)
self._p_str(" ")
if inherits != "":
self._p_str("is ")
self._p_str(inherits)
self._p_str(" ")
self._p_str("{")
self._p_nl()
self._with_indent(lambda: self._p_items(contract))
self._p_str("}")
self._p_nl()
def _p_items(self, contract: Cheatcodes):
for item in self.items_order.get_list():
if item == Item.ERROR:
self.p_errors(contract.errors)
elif item == Item.EVENT:
self.p_events(contract.events)
elif item == Item.ENUM:
self.p_enums(contract.enums)
elif item == Item.STRUCT:
self.p_structs(contract.structs)
elif item == Item.FUNCTION:
self.p_functions(contract.cheatcodes)
else:
assert False, f"unknown item {item}"
def p_prelude(self, contract: Optional[Cheatcodes] = None):
self._p_str(f"// SPDX-License-Identifier: {self.spdx_identifier}")
self._p_nl()
if self.solidity_requirement != "":
req = self.solidity_requirement
else:
req = ">=0.8.13 <0.9.0"
self._p_str(f"pragma solidity {req};")
self._p_nl()
self._p_nl()
def p_errors(self, errors: list[Error]):
for error in errors:
self._p_line(lambda: self.p_error(error))
def p_error(self, error: Error):
self._p_comment(error.description, doc=True)
self._p_line(lambda: self._p_str(error.declaration))
def p_events(self, events: list[Event]):
for event in events:
self._p_line(lambda: self.p_event(event))
def p_event(self, event: Event):
self._p_comment(event.description, doc=True)
self._p_line(lambda: self._p_str(event.declaration))
def p_enums(self, enums: list[Enum]):
for enum in enums:
self._p_line(lambda: self.p_enum(enum))
def p_enum(self, enum: Enum):
self._p_comment(enum.description, doc=True)
self._p_line(lambda: self._p_str(f"enum {enum.name} {{"))
self._with_indent(lambda: self.p_enum_variants(enum.variants))
self._p_line(lambda: self._p_str("}"))
def p_enum_variants(self, variants: list[EnumVariant]):
for i, variant in enumerate(variants):
self._p_indent()
self._p_comment(variant.description)
self._p_indent()
self._p_str(variant.name)
if i < len(variants) - 1:
self._p_str(",")
self._p_nl()
def p_structs(self, structs: list[Struct]):
for struct in structs:
self._p_line(lambda: self.p_struct(struct))
def p_struct(self, struct: Struct):
self._p_comment(struct.description, doc=True)
self._p_line(lambda: self._p_str(f"struct {struct.name} {{"))
self._with_indent(lambda: self.p_struct_fields(struct.fields))
self._p_line(lambda: self._p_str("}"))
def p_struct_fields(self, fields: list[StructField]):
for field in fields:
self._p_line(lambda: self.p_struct_field(field))
def p_struct_field(self, field: StructField):
self._p_comment(field.description)
self._p_indented(lambda: self._p_str(f"{field.ty} {field.name};"))
def p_functions(self, cheatcodes: list[Cheatcode]):
for cheatcode in cheatcodes:
self._p_line(lambda: self.p_function(cheatcode.func))
def p_function(self, func: Function):
self._p_comment(func.description, doc=True)
self._p_line(lambda: self._p_str(func.declaration))
def _p_comment(self, s: str, doc: bool = False):
s = s.strip()
if s == "":
return
s = map(lambda line: line.lstrip(), s.split("\n"))
if self.block_doc_style:
self._p_str("/*")
if doc:
self._p_str("*")
self._p_nl()
for line in s:
self._p_indent()
self._p_str(" ")
if doc:
self._p_str("* ")
self._p_str(line)
self._p_nl()
self._p_indent()
self._p_str(" */")
self._p_nl()
else:
first_line = True
for line in s:
if not first_line:
self._p_indent()
first_line = False
if doc:
self._p_str("/// ")
else:
self._p_str("// ")
self._p_str(line)
self._p_nl()
def _with_indent(self, f: VoidFn):
self._inc_indent()
f()
self._dec_indent()
def _p_line(self, f: VoidFn):
self._p_indent()
f()
self._p_nl()
def _p_indented(self, f: VoidFn):
self._p_indent()
f()
def _p_indent(self):
for _ in range(self.indent_level):
self._p_str(self._indent_str)
def _p_nl(self):
self._p_str(self.nl_str)
def _p_str(self, txt: str):
self.buffer += txt
def _inc_indent(self):
self.indent_level += 1
def _dec_indent(self):
self.indent_level -= 1
if __name__ == "__main__":
main()

48
packages/contracts/lib/forge-std/src/Base.sol Normal file
View file

@ -0,0 +1,48 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {StdStorage} from "./StdStorage.sol";
import {Vm, VmSafe} from "./Vm.sol";
abstract contract CommonBase {
/// @dev Cheat code address.
/// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.
address internal constant VM_ADDRESS = 0x7109709ECfa91a80626fF3989D68f67F5b1DD12D;
/// @dev console.sol and console2.sol work by executing a staticcall to this address.
/// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.
address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
/// @dev Used when deploying with create2.
/// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.
address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
/// @dev The default address for tx.origin and msg.sender.
/// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.
address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
/// @dev The address of the first contract `CREATE`d by a running test contract.
/// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.
/// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.
address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
/// @dev Deterministic deployment address of the Multicall3 contract.
/// Taken from https://www.multicall3.com.
address internal constant MULTICALL3_ADDRESS = 0xcA11bde05977b3631167028862bE2a173976CA11;
/// @dev The order of the secp256k1 curve.
uint256 internal constant SECP256K1_ORDER =
115792089237316195423570985008687907852837564279074904382605163141518161494337;
uint256 internal constant UINT256_MAX =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
Vm internal constant vm = Vm(VM_ADDRESS);
StdStorage internal stdstore;
}
abstract contract TestBase is CommonBase {}
abstract contract ScriptBase is CommonBase {
VmSafe internal constant vmSafe = VmSafe(VM_ADDRESS);
}

60
packages/contracts/lib/forge-std/src/Config.sol Normal file
View file

@ -0,0 +1,60 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.13;
import {console} from "./console.sol";
import {StdConfig} from "./StdConfig.sol";
import {CommonBase} from "./Base.sol";
/// @notice Boilerplate to streamline the setup of multi-chain environments.
abstract contract Config is CommonBase {
// -- STORAGE (CONFIG + CHAINS + FORKS) ------------------------------------
/// @dev Contract instance holding the data from the TOML config file.
StdConfig internal config;
/// @dev Array of chain IDs for which forks have been created.
uint256[] internal chainIds;
/// @dev A mapping from a chain ID to its initialized fork ID.
mapping(uint256 => uint256) internal forkOf;
// -- HELPER FUNCTIONS -----------------------------------------------------
/// @notice Loads configuration from a file.
///
/// @dev This function instantiates a `Config` contract, caching all its config variables.
///
/// @param filePath: the path to the TOML configuration file.
/// @param writeToFile: whether updates are written back to the TOML file.
function _loadConfig(string memory filePath, bool writeToFile) internal {
console.log("----------");
console.log(string.concat("Loading config from '", filePath, "'"));
config = new StdConfig(filePath, writeToFile);
vm.makePersistent(address(config));
console.log("Config successfully loaded");
console.log("----------");
}
/// @notice Loads configuration from a file and creates forks for each specified chain.
///
/// @dev This function instantiates a `Config` contract, caching all its config variables,
/// reads the configured chain ids, and iterates through them to create a fork for each one.
/// It also creates a map `forkOf[chainId] -> forkId` to easily switch between forks.
///
/// @param filePath: the path to the TOML configuration file.
/// @param writeToFile: whether updates are written back to the TOML file.
function _loadConfigAndForks(string memory filePath, bool writeToFile) internal {
_loadConfig(filePath, writeToFile);
console.log("Setting up forks for the configured chains...");
uint256[] memory chains = config.getChainIds();
for (uint256 i = 0; i < chains.length; i++) {
uint256 chainId = chains[i];
uint256 forkId = vm.createFork(config.getRpcUrl(chainId));
forkOf[chainId] = forkId;
chainIds.push(chainId);
}
console.log("Forks successfully created");
console.log("----------");
}
}

477
packages/contracts/lib/forge-std/src/LibVariable.sol Normal file
View file

@ -0,0 +1,477 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.13;
// Enable globally.
using LibVariable for Variable global;
struct Variable {
Type ty;
bytes data;
}
struct Type {
TypeKind kind;
bool isArray;
}
enum TypeKind {
None,
Bool,
Address,
Bytes32,
Uint256,
Int256,
String,
Bytes
}
/// @notice Library for type-safe coercion of the `Variable` struct to concrete types.
///
/// @dev Ensures that when a `Variable` is cast to a concrete Solidity type, the operation is safe and the
/// underlying type matches what is expected.
/// Provides functions to check types, convert them to strings, and coerce `Variable` instances into
/// both single values and arrays of various types.
///
/// Usage example:
/// ```solidity
/// import {LibVariable} from "./LibVariable.sol";
///
/// contract MyContract {
/// using LibVariable for Variable;
/// StdConfig config; // Assume 'config' is an instance of `StdConfig` and has already been loaded.
///
/// function readValues() public {
/// // Retrieve a 'uint256' value from the config.
/// uint256 myNumber = config.get("important_number").toUint256();
///
/// // Would revert with `TypeMismatch` as 'important_number' isn't a `uint256` in the config file.
/// // string memory notANumber = config.get("important_number").toString();
///
/// // Retrieve a address array from the config.
/// address[] memory admins = config.get("whitelisted_admins").toAddressArray();
/// }
/// }
/// ```
library LibVariable {
error NotInitialized();
error TypeMismatch(string expected, string actual);
error UnsafeCast(string message);
// -- TYPE HELPERS ----------------------------------------------------
/// @notice Compares two Type instances for equality.
function isEqual(Type memory self, Type memory other) internal pure returns (bool) {
return self.kind == other.kind && self.isArray == other.isArray;
}
/// @notice Compares two Type instances for equality. Reverts if they are not equal.
function assertEq(Type memory self, Type memory other) internal pure {
if (!isEqual(self, other)) {
revert TypeMismatch(toString(other), toString(self));
}
}
/// @notice Converts a Type struct to its full string representation (i.e. "uint256[]").
function toString(Type memory self) internal pure returns (string memory) {
string memory tyStr = toString(self.kind);
if (!self.isArray || self.kind == TypeKind.None) {
return tyStr;
} else {
return string.concat(tyStr, "[]");
}
}
/// @dev Converts a `TypeKind` enum to its base string representation.
function toString(TypeKind self) internal pure returns (string memory) {
if (self == TypeKind.Bool) return "bool";
if (self == TypeKind.Address) return "address";
if (self == TypeKind.Bytes32) return "bytes32";
if (self == TypeKind.Uint256) return "uint256";
if (self == TypeKind.Int256) return "int256";
if (self == TypeKind.String) return "string";
if (self == TypeKind.Bytes) return "bytes";
return "none";
}
/// @dev Converts a `TypeKind` enum to its base string representation.
function toTomlKey(TypeKind self) internal pure returns (string memory) {
if (self == TypeKind.Bool) return "bool";
if (self == TypeKind.Address) return "address";
if (self == TypeKind.Bytes32) return "bytes32";
if (self == TypeKind.Uint256) return "uint";
if (self == TypeKind.Int256) return "int";
if (self == TypeKind.String) return "string";
if (self == TypeKind.Bytes) return "bytes";
return "none";
}
// -- VARIABLE HELPERS ----------------------------------------------------
/// @dev Checks if a `Variable` has been initialized and matches the expected type reverting if not.
modifier check(Variable memory self, Type memory expected) {
assertExists(self);
assertEq(self.ty, expected);
_;
}
/// @dev Checks if a `Variable` has been initialized, reverting if not.
function assertExists(Variable memory self) public pure {
if (self.ty.kind == TypeKind.None) {
revert NotInitialized();
}
}
// -- VARIABLE COERCION FUNCTIONS (SINGLE VALUES) --------------------------
/// @notice Coerces a `Variable` to a `bool` value.
function toBool(Variable memory self) internal pure check(self, Type(TypeKind.Bool, false)) returns (bool) {
return abi.decode(self.data, (bool));
}
/// @notice Coerces a `Variable` to an `address` value.
function toAddress(Variable memory self)
internal
pure
check(self, Type(TypeKind.Address, false))
returns (address)
{
return abi.decode(self.data, (address));
}
/// @notice Coerces a `Variable` to a `bytes32` value.
function toBytes32(Variable memory self)
internal
pure
check(self, Type(TypeKind.Bytes32, false))
returns (bytes32)
{
return abi.decode(self.data, (bytes32));
}
/// @notice Coerces a `Variable` to a `uint256` value.
function toUint256(Variable memory self)
internal
pure
check(self, Type(TypeKind.Uint256, false))
returns (uint256)
{
return abi.decode(self.data, (uint256));
}
/// @notice Coerces a `Variable` to a `uint128` value, checking for overflow.
function toUint128(Variable memory self) internal pure returns (uint128) {
uint256 value = self.toUint256();
if (value > type(uint128).max) {
revert UnsafeCast("value does not fit in 'uint128'");
}
return uint128(value);
}
/// @notice Coerces a `Variable` to a `uint64` value, checking for overflow.
function toUint64(Variable memory self) internal pure returns (uint64) {
uint256 value = self.toUint256();
if (value > type(uint64).max) {
revert UnsafeCast("value does not fit in 'uint64'");
}
return uint64(value);
}
/// @notice Coerces a `Variable` to a `uint32` value, checking for overflow.
function toUint32(Variable memory self) internal pure returns (uint32) {
uint256 value = self.toUint256();
if (value > type(uint32).max) {
revert UnsafeCast("value does not fit in 'uint32'");
}
return uint32(value);
}
/// @notice Coerces a `Variable` to a `uint16` value, checking for overflow.
function toUint16(Variable memory self) internal pure returns (uint16) {
uint256 value = self.toUint256();
if (value > type(uint16).max) {
revert UnsafeCast("value does not fit in 'uint16'");
}
return uint16(value);
}
/// @notice Coerces a `Variable` to a `uint8` value, checking for overflow.
function toUint8(Variable memory self) internal pure returns (uint8) {
uint256 value = self.toUint256();
if (value > type(uint8).max) {
revert UnsafeCast("value does not fit in 'uint8'");
}
return uint8(value);
}
/// @notice Coerces a `Variable` to an `int256` value.
function toInt256(Variable memory self) internal pure check(self, Type(TypeKind.Int256, false)) returns (int256) {
return abi.decode(self.data, (int256));
}
/// @notice Coerces a `Variable` to an `int128` value, checking for overflow/underflow.
function toInt128(Variable memory self) internal pure returns (int128) {
int256 value = self.toInt256();
if (value > type(int128).max || value < type(int128).min) {
revert UnsafeCast("value does not fit in 'int128'");
}
return int128(value);
}
/// @notice Coerces a `Variable` to an `int64` value, checking for overflow/underflow.
function toInt64(Variable memory self) internal pure returns (int64) {
int256 value = self.toInt256();
if (value > type(int64).max || value < type(int64).min) {
revert UnsafeCast("value does not fit in 'int64'");
}
return int64(value);
}
/// @notice Coerces a `Variable` to an `int32` value, checking for overflow/underflow.
function toInt32(Variable memory self) internal pure returns (int32) {
int256 value = self.toInt256();
if (value > type(int32).max || value < type(int32).min) {
revert UnsafeCast("value does not fit in 'int32'");
}
return int32(value);
}
/// @notice Coerces a `Variable` to an `int16` value, checking for overflow/underflow.
function toInt16(Variable memory self) internal pure returns (int16) {
int256 value = self.toInt256();
if (value > type(int16).max || value < type(int16).min) {
revert UnsafeCast("value does not fit in 'int16'");
}
return int16(value);
}
/// @notice Coerces a `Variable` to an `int8` value, checking for overflow/underflow.
function toInt8(Variable memory self) internal pure returns (int8) {
int256 value = self.toInt256();
if (value > type(int8).max || value < type(int8).min) {
revert UnsafeCast("value does not fit in 'int8'");
}
return int8(value);
}
/// @notice Coerces a `Variable` to a `string` value.
function toString(Variable memory self)
internal
pure
check(self, Type(TypeKind.String, false))
returns (string memory)
{
return abi.decode(self.data, (string));
}
/// @notice Coerces a `Variable` to a `bytes` value.
function toBytes(Variable memory self)
internal
pure
check(self, Type(TypeKind.Bytes, false))
returns (bytes memory)
{
return abi.decode(self.data, (bytes));
}
// -- VARIABLE COERCION FUNCTIONS (ARRAYS) ---------------------------------
/// @notice Coerces a `Variable` to a `bool` array.
function toBoolArray(Variable memory self)
internal
pure
check(self, Type(TypeKind.Bool, true))
returns (bool[] memory)
{
return abi.decode(self.data, (bool[]));
}
/// @notice Coerces a `Variable` to an `address` array.
function toAddressArray(Variable memory self)
internal
pure
check(self, Type(TypeKind.Address, true))
returns (address[] memory)
{
return abi.decode(self.data, (address[]));
}
/// @notice Coerces a `Variable` to a `bytes32` array.
function toBytes32Array(Variable memory self)
internal
pure
check(self, Type(TypeKind.Bytes32, true))
returns (bytes32[] memory)
{
return abi.decode(self.data, (bytes32[]));
}
/// @notice Coerces a `Variable` to a `uint256` array.
function toUint256Array(Variable memory self)
internal
pure
check(self, Type(TypeKind.Uint256, true))
returns (uint256[] memory)
{
return abi.decode(self.data, (uint256[]));
}
/// @notice Coerces a `Variable` to a `uint128` array, checking for overflow.
function toUint128Array(Variable memory self) internal pure returns (uint128[] memory) {
uint256[] memory values = self.toUint256Array();
uint128[] memory result = new uint128[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(uint128).max) {
revert UnsafeCast("value in array does not fit in 'uint128'");
}
result[i] = uint128(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `uint64` array, checking for overflow.
function toUint64Array(Variable memory self) internal pure returns (uint64[] memory) {
uint256[] memory values = self.toUint256Array();
uint64[] memory result = new uint64[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(uint64).max) {
revert UnsafeCast("value in array does not fit in 'uint64'");
}
result[i] = uint64(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `uint32` array, checking for overflow.
function toUint32Array(Variable memory self) internal pure returns (uint32[] memory) {
uint256[] memory values = self.toUint256Array();
uint32[] memory result = new uint32[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(uint32).max) {
revert UnsafeCast("value in array does not fit in 'uint32'");
}
result[i] = uint32(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `uint16` array, checking for overflow.
function toUint16Array(Variable memory self) internal pure returns (uint16[] memory) {
uint256[] memory values = self.toUint256Array();
uint16[] memory result = new uint16[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(uint16).max) {
revert UnsafeCast("value in array does not fit in 'uint16'");
}
result[i] = uint16(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `uint8` array, checking for overflow.
function toUint8Array(Variable memory self) internal pure returns (uint8[] memory) {
uint256[] memory values = self.toUint256Array();
uint8[] memory result = new uint8[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(uint8).max) {
revert UnsafeCast("value in array does not fit in 'uint8'");
}
result[i] = uint8(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to an `int256` array.
function toInt256Array(Variable memory self)
internal
pure
check(self, Type(TypeKind.Int256, true))
returns (int256[] memory)
{
return abi.decode(self.data, (int256[]));
}
/// @notice Coerces a `Variable` to a `int128` array, checking for overflow/underflow.
function toInt128Array(Variable memory self) internal pure returns (int128[] memory) {
int256[] memory values = self.toInt256Array();
int128[] memory result = new int128[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(int128).max || values[i] < type(int128).min) {
revert UnsafeCast("value in array does not fit in 'int128'");
}
result[i] = int128(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `int64` array, checking for overflow/underflow.
function toInt64Array(Variable memory self) internal pure returns (int64[] memory) {
int256[] memory values = self.toInt256Array();
int64[] memory result = new int64[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(int64).max || values[i] < type(int64).min) {
revert UnsafeCast("value in array does not fit in 'int64'");
}
result[i] = int64(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `int32` array, checking for overflow/underflow.
function toInt32Array(Variable memory self) internal pure returns (int32[] memory) {
int256[] memory values = self.toInt256Array();
int32[] memory result = new int32[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(int32).max || values[i] < type(int32).min) {
revert UnsafeCast("value in array does not fit in 'int32'");
}
result[i] = int32(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `int16` array, checking for overflow/underflow.
function toInt16Array(Variable memory self) internal pure returns (int16[] memory) {
int256[] memory values = self.toInt256Array();
int16[] memory result = new int16[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(int16).max || values[i] < type(int16).min) {
revert UnsafeCast("value in array does not fit in 'int16'");
}
result[i] = int16(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `int8` array, checking for overflow/underflow.
function toInt8Array(Variable memory self) internal pure returns (int8[] memory) {
int256[] memory values = self.toInt256Array();
int8[] memory result = new int8[](values.length);
for (uint256 i = 0; i < values.length; i++) {
if (values[i] > type(int8).max || values[i] < type(int8).min) {
revert UnsafeCast("value in array does not fit in 'int8'");
}
result[i] = int8(values[i]);
}
return result;
}
/// @notice Coerces a `Variable` to a `string` array.
function toStringArray(Variable memory self)
internal
pure
check(self, Type(TypeKind.String, true))
returns (string[] memory)
{
return abi.decode(self.data, (string[]));
}
/// @notice Coerces a `Variable` to a `bytes` array.
function toBytesArray(Variable memory self)
internal
pure
check(self, Type(TypeKind.Bytes, true))
returns (bytes[] memory)
{
return abi.decode(self.data, (bytes[]));
}
}

28
packages/contracts/lib/forge-std/src/Script.sol Normal file
View file

@ -0,0 +1,28 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
// 💬 ABOUT
// Forge Std's default Script.
// 🧩 MODULES
import {console} from "./console.sol";
import {console2} from "./console2.sol";
import {safeconsole} from "./safeconsole.sol";
import {StdChains} from "./StdChains.sol";
import {StdCheatsSafe} from "./StdCheats.sol";
import {StdConstants} from "./StdConstants.sol";
import {stdJson} from "./StdJson.sol";
import {stdMath} from "./StdMath.sol";
import {StdStorage, stdStorageSafe} from "./StdStorage.sol";
import {StdStyle} from "./StdStyle.sol";
import {StdUtils} from "./StdUtils.sol";
import {VmSafe} from "./Vm.sol";
// 📦 BOILERPLATE
import {ScriptBase} from "./Base.sol";
// ⭐️ SCRIPT
abstract contract Script is ScriptBase, StdChains, StdCheatsSafe, StdUtils {
// Note: IS_SCRIPT() must return true.
bool public IS_SCRIPT = true;
}

1300
packages/contracts/lib/forge-std/src/StdAssertions.sol Normal file
View file

File diff suppressed because it is too large Load diff

316
packages/contracts/lib/forge-std/src/StdChains.sol Normal file
View file

@ -0,0 +1,316 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {VmSafe} from "./Vm.sol";
/**
* StdChains provides information about EVM compatible chains that can be used in scripts/tests.
* For each chain, the chain's name, chain ID, and a default RPC URL are provided. Chains are
* identified by their alias, which is the same as the alias in the `[rpc_endpoints]` section of
* the `foundry.toml` file. For best UX, ensure the alias in the `foundry.toml` file matches the
* alias used in this contract, which can be found as the first argument to the
* `_setChainWithDefaultRpcUrl` call in the `_initializeStdChains` function.
*
* There are two main ways to use this contract:
* 1. Set a chain with `setChain(string memory chainAlias, ChainData memory chain)` or
* `setChain(string memory chainAlias, Chain memory chain)`
* 2. Get a chain with `getChain(string memory chainAlias)` or `getChain(uint256 chainId)`.
*
* The first time either of those are used, chains are initialized with the default set of RPC URLs.
* This is done in `_initializeStdChains`, which uses `_setChainWithDefaultRpcUrl`. Defaults are recorded in
* `_defaultRpcUrls`.
*
* The `setChain` function is straightforward, and it simply saves off the given chain data.
*
* The `getChain` methods use `_getChainWithUpdatedRpcUrl` to return a chain. For example, let's say
* we want to retrieve the RPC URL for `mainnet`:
* - If you have specified data with `setChain`, it will return that.
* - If you have configured a mainnet RPC URL in `foundry.toml`, it will return the URL, provided it
* is valid (e.g. a URL is specified, or an environment variable is given and exists).
* - If neither of the above conditions is met, the default data is returned.
*
* Summarizing the above, the prioritization hierarchy is `setChain` -> `foundry.toml` -> environment variable -> defaults.
*/
abstract contract StdChains {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
bool private _stdChainsInitialized;
struct ChainData {
string name;
uint256 chainId;
string rpcUrl;
}
struct Chain {
// The chain name.
string name;
// The chain's Chain ID.
uint256 chainId;
// The chain's alias. (i.e. what gets specified in `foundry.toml`).
string chainAlias;
// A default RPC endpoint for this chain.
// NOTE: This default RPC URL is included for convenience to facilitate quick tests and
// experimentation. Do not use this RPC URL for production test suites, CI, or other heavy
// usage as you will be throttled and this is a disservice to others who need this endpoint.
string rpcUrl;
}
// Maps from the chain's alias (matching the alias in the `foundry.toml` file) to chain data.
mapping(string => Chain) private _chains;
// Maps from the chain's alias to its default RPC URL.
mapping(string => string) private _defaultRpcUrls;
// Maps from a chain ID to its alias.
mapping(uint256 => string) private _idToAlias;
bool private _fallbackToDefaultRpcUrls = true;
/// @notice Returns chain data for the given alias, with the RPC URL resolved from config or defaults.
/// @dev Reverts if `chainAlias` is empty or has not been registered.
function getChain(string memory chainAlias) internal virtual returns (Chain memory chain) {
require(bytes(chainAlias).length != 0, "StdChains getChain(string): Chain alias cannot be the empty string.");
_initializeStdChains();
chain = _chains[chainAlias];
require(
chain.chainId != 0,
string(abi.encodePacked("StdChains getChain(string): Chain with alias \"", chainAlias, "\" not found."))
);
chain = _getChainWithUpdatedRpcUrl(chainAlias, chain);
}
/// @notice Returns chain data for the given chain ID, with the RPC URL resolved from config or defaults.
/// @dev Reverts if `chainId` is `0` or has not been registered.
function getChain(uint256 chainId) internal virtual returns (Chain memory chain) {
require(chainId != 0, "StdChains getChain(uint256): Chain ID cannot be 0.");
_initializeStdChains();
string memory chainAlias = _idToAlias[chainId];
chain = _chains[chainAlias];
require(
chain.chainId != 0,
string(abi.encodePacked("StdChains getChain(uint256): Chain with ID ", vm.toString(chainId), " not found."))
);
chain = _getChainWithUpdatedRpcUrl(chainAlias, chain);
}
/// @notice Registers chain data under `chainAlias`, with priority given to the argument's `rpcUrl` field.
function setChain(string memory chainAlias, ChainData memory chain) internal virtual {
require(
bytes(chainAlias).length != 0,
"StdChains setChain(string,ChainData): Chain alias cannot be the empty string."
);
require(chain.chainId != 0, "StdChains setChain(string,ChainData): Chain ID cannot be 0.");
_initializeStdChains();
string memory foundAlias = _idToAlias[chain.chainId];
require(
bytes(foundAlias).length == 0 || keccak256(bytes(foundAlias)) == keccak256(bytes(chainAlias)),
string(
abi.encodePacked(
"StdChains setChain(string,ChainData): Chain ID ",
vm.toString(chain.chainId),
" already used by \"",
foundAlias,
"\"."
)
)
);
uint256 oldChainId = _chains[chainAlias].chainId;
delete _idToAlias[oldChainId];
_chains[chainAlias] =
Chain({name: chain.name, chainId: chain.chainId, chainAlias: chainAlias, rpcUrl: chain.rpcUrl});
_idToAlias[chain.chainId] = chainAlias;
}
/// @notice Registers chain data under `chainAlias`, with priority given to the argument's `rpcUrl` field.
function setChain(string memory chainAlias, Chain memory chain) internal virtual {
setChain(chainAlias, ChainData({name: chain.name, chainId: chain.chainId, rpcUrl: chain.rpcUrl}));
}
function _toUpper(string memory str) private pure returns (string memory) {
bytes memory strb = bytes(str);
bytes memory copy = new bytes(strb.length);
for (uint256 i = 0; i < strb.length; i++) {
bytes1 b = strb[i];
if (b >= 0x61 && b <= 0x7A) {
copy[i] = bytes1(uint8(b) - 32);
} else {
copy[i] = b;
}
}
return string(copy);
}
// lookup rpcUrl, in descending order of priority:
// current -> config (foundry.toml) -> environment variable -> default
function _getChainWithUpdatedRpcUrl(string memory chainAlias, Chain memory chain)
private
view
returns (Chain memory)
{
if (bytes(chain.rpcUrl).length == 0) {
try vm.rpcUrl(chainAlias) returns (string memory configRpcUrl) {
chain.rpcUrl = configRpcUrl;
} catch (bytes memory err) {
string memory envName = string(abi.encodePacked(_toUpper(chainAlias), "_RPC_URL"));
if (_fallbackToDefaultRpcUrls) {
chain.rpcUrl = vm.envOr(envName, _defaultRpcUrls[chainAlias]);
} else {
chain.rpcUrl = vm.envString(envName);
}
// Distinguish 'not found' from 'cannot read'
// The upstream error thrown by forge for failing cheats changed so we check both the old and new versions
bytes memory oldNotFoundError =
abi.encodeWithSignature("CheatCodeError", string(abi.encodePacked("invalid rpc url ", chainAlias)));
bytes memory newNotFoundError = abi.encodeWithSignature(
"CheatcodeError(string)", string(abi.encodePacked("invalid rpc url: ", chainAlias))
);
bytes32 errHash = keccak256(err);
if (
(errHash != keccak256(oldNotFoundError) && errHash != keccak256(newNotFoundError))
|| bytes(chain.rpcUrl).length == 0
) {
assembly ("memory-safe") {
revert(add(32, err), mload(err))
}
}
}
}
return chain;
}
/// @notice Sets whether to fall back to default RPC URLs when no URL is configured for a chain.
function setFallbackToDefaultRpcUrls(bool useDefault) internal {
_fallbackToDefaultRpcUrls = useDefault;
}
function _initializeStdChains() private {
if (_stdChainsInitialized) return;
_stdChainsInitialized = true;
// If adding an RPC here, make sure to test the default RPC URL in `test_Rpcs` in `StdChains.t.sol`
_setChainWithDefaultRpcUrl("anvil", ChainData("Anvil", 31337, "http://127.0.0.1:8545"));
_setChainWithDefaultRpcUrl("mainnet", ChainData("Mainnet", 1, "https://eth.llamarpc.com"));
_setChainWithDefaultRpcUrl(
"sepolia", ChainData("Sepolia", 11155111, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001")
);
_setChainWithDefaultRpcUrl("holesky", ChainData("Holesky", 17000, "https://rpc.holesky.ethpandaops.io"));
_setChainWithDefaultRpcUrl("hoodi", ChainData("Hoodi", 560048, "https://rpc.hoodi.ethpandaops.io"));
_setChainWithDefaultRpcUrl("optimism", ChainData("Optimism", 10, "https://mainnet.optimism.io"));
_setChainWithDefaultRpcUrl(
"optimism_sepolia", ChainData("Optimism Sepolia", 11155420, "https://sepolia.optimism.io")
);
_setChainWithDefaultRpcUrl("arbitrum_one", ChainData("Arbitrum One", 42161, "https://arb1.arbitrum.io/rpc"));
_setChainWithDefaultRpcUrl(
"arbitrum_one_sepolia", ChainData("Arbitrum One Sepolia", 421614, "https://sepolia-rollup.arbitrum.io/rpc")
);
_setChainWithDefaultRpcUrl("arbitrum_nova", ChainData("Arbitrum Nova", 42170, "https://nova.arbitrum.io/rpc"));
_setChainWithDefaultRpcUrl("polygon", ChainData("Polygon", 137, "https://polygon-rpc.com"));
_setChainWithDefaultRpcUrl(
"polygon_amoy", ChainData("Polygon Amoy", 80002, "https://rpc-amoy.polygon.technology")
);
_setChainWithDefaultRpcUrl("avalanche", ChainData("Avalanche", 43114, "https://api.avax.network/ext/bc/C/rpc"));
_setChainWithDefaultRpcUrl(
"avalanche_fuji", ChainData("Avalanche Fuji", 43113, "https://api.avax-test.network/ext/bc/C/rpc")
);
_setChainWithDefaultRpcUrl(
"bnb_smart_chain", ChainData("BNB Smart Chain", 56, "https://bsc-dataseed1.binance.org")
);
_setChainWithDefaultRpcUrl(
"bnb_smart_chain_testnet",
ChainData("BNB Smart Chain Testnet", 97, "https://rpc.ankr.com/bsc_testnet_chapel")
);
_setChainWithDefaultRpcUrl("gnosis_chain", ChainData("Gnosis Chain", 100, "https://rpc.gnosischain.com"));
_setChainWithDefaultRpcUrl("moonbeam", ChainData("Moonbeam", 1284, "https://rpc.api.moonbeam.network"));
_setChainWithDefaultRpcUrl(
"moonriver", ChainData("Moonriver", 1285, "https://rpc.api.moonriver.moonbeam.network")
);
_setChainWithDefaultRpcUrl("moonbase", ChainData("Moonbase", 1287, "https://rpc.testnet.moonbeam.network"));
_setChainWithDefaultRpcUrl("base_sepolia", ChainData("Base Sepolia", 84532, "https://sepolia.base.org"));
_setChainWithDefaultRpcUrl("base", ChainData("Base", 8453, "https://mainnet.base.org"));
_setChainWithDefaultRpcUrl("blast_sepolia", ChainData("Blast Sepolia", 168587773, "https://sepolia.blast.io"));
_setChainWithDefaultRpcUrl("blast", ChainData("Blast", 81457, "https://rpc.blast.io"));
_setChainWithDefaultRpcUrl("fantom_opera", ChainData("Fantom Opera", 250, "https://rpc.ankr.com/fantom/"));
_setChainWithDefaultRpcUrl(
"fantom_opera_testnet", ChainData("Fantom Opera Testnet", 4002, "https://rpc.ankr.com/fantom_testnet/")
);
_setChainWithDefaultRpcUrl("fraxtal", ChainData("Fraxtal", 252, "https://rpc.frax.com"));
_setChainWithDefaultRpcUrl(
"fraxtal_testnet", ChainData("Fraxtal Testnet", 2522, "https://rpc.testnet.frax.com")
);
_setChainWithDefaultRpcUrl(
"berachain_bartio_testnet", ChainData("Berachain bArtio Testnet", 80084, "https://bartio.rpc.berachain.com")
);
_setChainWithDefaultRpcUrl("flare", ChainData("Flare", 14, "https://flare-api.flare.network/ext/C/rpc"));
_setChainWithDefaultRpcUrl(
"flare_coston2", ChainData("Flare Coston2", 114, "https://coston2-api.flare.network/ext/C/rpc")
);
_setChainWithDefaultRpcUrl("ink", ChainData("Ink", 57073, "https://rpc-gel.inkonchain.com"));
_setChainWithDefaultRpcUrl(
"ink_sepolia", ChainData("Ink Sepolia", 763373, "https://rpc-gel-sepolia.inkonchain.com")
);
_setChainWithDefaultRpcUrl("mode", ChainData("Mode", 34443, "https://mode.drpc.org"));
_setChainWithDefaultRpcUrl("mode_sepolia", ChainData("Mode Sepolia", 919, "https://sepolia.mode.network"));
_setChainWithDefaultRpcUrl("zora", ChainData("Zora", 7777777, "https://zora.drpc.org"));
_setChainWithDefaultRpcUrl(
"zora_sepolia", ChainData("Zora Sepolia", 999999999, "https://sepolia.rpc.zora.energy")
);
_setChainWithDefaultRpcUrl("race", ChainData("Race", 6805, "https://racemainnet.io"));
_setChainWithDefaultRpcUrl("race_sepolia", ChainData("Race Sepolia", 6806, "https://racemainnet.io"));
_setChainWithDefaultRpcUrl("radius", ChainData("Radius", 723487, "https://rpc.radiustech.xyz"));
_setChainWithDefaultRpcUrl(
"radius_testnet", ChainData("Radius Testnet", 72344, "https://rpc.testnet.radiustech.xyz")
);
_setChainWithDefaultRpcUrl("metal", ChainData("Metal", 1750, "https://metall2.drpc.org"));
_setChainWithDefaultRpcUrl("metal_sepolia", ChainData("Metal Sepolia", 1740, "https://testnet.rpc.metall2.com"));
_setChainWithDefaultRpcUrl("binary", ChainData("Binary", 624, "https://rpc.zero.thebinaryholdings.com"));
_setChainWithDefaultRpcUrl(
"binary_sepolia", ChainData("Binary Sepolia", 625, "https://rpc.zero.thebinaryholdings.com")
);
_setChainWithDefaultRpcUrl("orderly", ChainData("Orderly", 291, "https://rpc.orderly.network"));
_setChainWithDefaultRpcUrl(
"orderly_sepolia", ChainData("Orderly Sepolia", 4460, "https://testnet-rpc.orderly.org")
);
_setChainWithDefaultRpcUrl("unichain", ChainData("Unichain", 130, "https://mainnet.unichain.org"));
_setChainWithDefaultRpcUrl(
"unichain_sepolia", ChainData("Unichain Sepolia", 1301, "https://sepolia.unichain.org")
);
_setChainWithDefaultRpcUrl("tempo", ChainData("Tempo", 4217, "https://rpc.mainnet.tempo.xyz"));
_setChainWithDefaultRpcUrl(
"tempo_moderato", ChainData("Tempo Moderato", 42431, "https://rpc.moderato.tempo.xyz")
);
_setChainWithDefaultRpcUrl(
"tempo_andantino", ChainData("Tempo Andantino", 42429, "https://rpc.testnet.tempo.xyz")
);
_setChainWithDefaultRpcUrl("grav", ChainData("Gravity", 127001, "https://mainnet-rpc.gravity.xyz"));
}
// set chain info, with priority to chainAlias' rpc url in foundry.toml
function _setChainWithDefaultRpcUrl(string memory chainAlias, ChainData memory chain) private {
string memory rpcUrl = chain.rpcUrl;
_defaultRpcUrls[chainAlias] = rpcUrl;
chain.rpcUrl = "";
setChain(chainAlias, chain);
chain.rpcUrl = rpcUrl; // restore argument
}
}

922
packages/contracts/lib/forge-std/src/StdCheats.sol Normal file
View file

@ -0,0 +1,922 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {StdStorage, stdStorage} from "./StdStorage.sol";
import {console2} from "./console2.sol";
import {Vm} from "./Vm.sol";
abstract contract StdCheatsSafe {
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
uint256 private constant _UINT256_MAX =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
bool private _gasMeteringOff;
// Data structures to parse Transaction objects from the broadcast artifact
// that conform to EIP1559. The Raw structs are what are parsed from the JSON
// and then converted to the one that is used by the user for better UX.
struct RawTx1559 {
string[] arguments;
address contractAddress;
string contractName;
// json value name = function
string functionSig;
bytes32 hash;
// json value name = tx
RawTx1559Detail txDetail;
// json value name = type
string opcode;
}
struct RawTx1559Detail {
AccessList[] accessList;
bytes data;
address from;
bytes gas;
bytes nonce;
address to;
bytes txType;
bytes value;
}
struct Tx1559 {
string[] arguments;
address contractAddress;
string contractName;
string functionSig;
bytes32 hash;
Tx1559Detail txDetail;
string opcode;
}
struct Tx1559Detail {
AccessList[] accessList;
bytes data;
address from;
uint256 gas;
uint256 nonce;
address to;
uint256 txType;
uint256 value;
}
// Data structures to parse Transaction objects from the broadcast artifact
// that DO NOT conform to EIP1559. The Raw structs are what are parsed from the JSON
// and then converted to the one that is used by the user for better UX.
struct TxLegacy {
string[] arguments;
address contractAddress;
string contractName;
string functionSig;
string hash;
string opcode;
TxDetailLegacy transaction;
}
struct TxDetailLegacy {
AccessList[] accessList;
uint256 chainId;
bytes data;
address from;
uint256 gas;
uint256 gasPrice;
bytes32 hash;
uint256 nonce;
bytes1 opcode;
bytes32 r;
bytes32 s;
uint256 txType;
address to;
uint8 v;
uint256 value;
}
struct AccessList {
address accessAddress;
bytes32[] storageKeys;
}
// Data structures to parse Receipt objects from the broadcast artifact.
// The Raw structs is what is parsed from the JSON
// and then converted to the one that is used by the user for better UX.
struct RawReceipt {
bytes32 blockHash;
bytes blockNumber;
address contractAddress;
bytes cumulativeGasUsed;
bytes effectiveGasPrice;
address from;
bytes gasUsed;
RawReceiptLog[] logs;
bytes logsBloom;
bytes status;
address to;
bytes32 transactionHash;
bytes transactionIndex;
}
struct Receipt {
bytes32 blockHash;
uint256 blockNumber;
address contractAddress;
uint256 cumulativeGasUsed;
uint256 effectiveGasPrice;
address from;
uint256 gasUsed;
ReceiptLog[] logs;
bytes logsBloom;
uint256 status;
address to;
bytes32 transactionHash;
uint256 transactionIndex;
}
// Data structures to parse the entire broadcast artifact, assuming the
// transactions conform to EIP1559.
struct EIP1559ScriptArtifact {
string[] libraries;
string path;
string[] pending;
Receipt[] receipts;
uint256 timestamp;
Tx1559[] transactions;
TxReturn[] txReturns;
}
struct RawEIP1559ScriptArtifact {
string[] libraries;
string path;
string[] pending;
RawReceipt[] receipts;
TxReturn[] txReturns;
uint256 timestamp;
RawTx1559[] transactions;
}
struct RawReceiptLog {
// json value = address
address logAddress;
bytes32 blockHash;
bytes blockNumber;
bytes data;
bytes logIndex;
bool removed;
bytes32[] topics;
bytes32 transactionHash;
bytes transactionIndex;
bytes transactionLogIndex;
}
struct ReceiptLog {
// json value = address
address logAddress;
bytes32 blockHash;
uint256 blockNumber;
bytes data;
uint256 logIndex;
bytes32[] topics;
uint256 transactionIndex;
uint256 transactionLogIndex;
bool removed;
}
struct TxReturn {
string internalType;
string value;
}
struct Account {
address addr;
uint256 key;
}
enum AddressType {
Payable,
NonPayable,
ZeroAddress,
Precompile,
ForgeAddress
}
/// @notice Assumes `addr` is not blacklisted by `token`, skipping the fuzz run if it is.
function assumeNotBlacklisted(address token, address addr) internal view virtual {
// Nothing to check if `token` is not a contract.
uint256 tokenCodeSize;
assembly {
tokenCodeSize := extcodesize(token)
}
require(tokenCodeSize > 0, "StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
bool success;
bytes memory returnData;
// 4-byte selector for `isBlacklisted(address)`, used by USDC.
(success, returnData) = token.staticcall(abi.encodeWithSelector(0xfe575a87, addr));
vm.assume(!success || abi.decode(returnData, (bool)) == false);
// 4-byte selector for `isBlackListed(address)`, used by USDT.
(success, returnData) = token.staticcall(abi.encodeWithSelector(0xe47d6060, addr));
vm.assume(!success || abi.decode(returnData, (bool)) == false);
}
/// @notice Assumes `addr` is not blacklisted by `token`, skipping the fuzz run if it is.
/// @dev Deprecated alias for `assumeNotBlacklisted`. Will be removed in a future breaking release.
function assumeNoBlacklisted(address token, address addr) internal view virtual {
assumeNotBlacklisted(token, addr);
}
/// @notice Assumes `addr` does not match `addressType`, skipping the fuzz run if it does.
function assumeAddressIsNot(address addr, AddressType addressType) internal virtual {
if (addressType == AddressType.Payable) {
assumeNotPayable(addr);
} else if (addressType == AddressType.NonPayable) {
assumePayable(addr);
} else if (addressType == AddressType.ZeroAddress) {
assumeNotZeroAddress(addr);
} else if (addressType == AddressType.Precompile) {
assumeNotPrecompile(addr);
} else if (addressType == AddressType.ForgeAddress) {
assumeNotForgeAddress(addr);
}
}
/// @notice Assumes `addr` does not match `addressType1` or `addressType2`, skipping the fuzz run if it does.
function assumeAddressIsNot(address addr, AddressType addressType1, AddressType addressType2) internal virtual {
assumeAddressIsNot(addr, addressType1);
assumeAddressIsNot(addr, addressType2);
}
/// @notice Assumes `addr` does not match any of the three given address types, skipping the fuzz run if it does.
function assumeAddressIsNot(
address addr,
AddressType addressType1,
AddressType addressType2,
AddressType addressType3
) internal virtual {
assumeAddressIsNot(addr, addressType1);
assumeAddressIsNot(addr, addressType2);
assumeAddressIsNot(addr, addressType3);
}
/// @notice Assumes `addr` does not match any of the four given address types, skipping the fuzz run if it does.
function assumeAddressIsNot(
address addr,
AddressType addressType1,
AddressType addressType2,
AddressType addressType3,
AddressType addressType4
) internal virtual {
assumeAddressIsNot(addr, addressType1);
assumeAddressIsNot(addr, addressType2);
assumeAddressIsNot(addr, addressType3);
assumeAddressIsNot(addr, addressType4);
}
// This function checks whether an address, `addr`, is payable. It works by sending 1 wei to
// `addr` and checking the `success` return value.
// NOTE: This function may result in state changes depending on the fallback/receive logic
// implemented by `addr`, which should be taken into account when this function is used.
function _isPayable(address addr) private returns (bool) {
require(
addr.balance < _UINT256_MAX,
"StdCheats _isPayable(address): Balance equals max uint256, so it cannot receive any more funds"
);
uint256 origBalanceTest = address(this).balance;
uint256 origBalanceAddr = address(addr).balance;
vm.deal(address(this), 1);
(bool success,) = payable(addr).call{value: 1}("");
// reset balances
vm.deal(address(this), origBalanceTest);
vm.deal(addr, origBalanceAddr);
return success;
}
/// @notice Assumes `addr` is a payable address, skipping the fuzz run if it is not.
/// @dev May cause state changes depending on `addr`'s fallback or receive logic.
function assumePayable(address addr) internal virtual {
vm.assume(_isPayable(addr));
}
/// @notice Assumes `addr` is not a payable address, skipping the fuzz run if it is.
/// @dev May cause state changes depending on `addr`'s fallback or receive logic.
function assumeNotPayable(address addr) internal virtual {
vm.assume(!_isPayable(addr));
}
/// @notice Assumes `addr` is not the zero address, skipping the fuzz run if it is.
function assumeNotZeroAddress(address addr) internal pure virtual {
vm.assume(addr != address(0));
}
/// @notice Assumes `addr` is not a precompile on the current chain, skipping the fuzz run if it is.
function assumeNotPrecompile(address addr) internal pure virtual {
assumeNotPrecompile(addr, _pureChainId());
}
/// @notice Assumes `addr` is not a precompile on `chainId`, skipping the fuzz run if it is.
function assumeNotPrecompile(address addr, uint256 chainId) internal pure virtual {
// Note: For some chains like Optimism these are technically predeploys (i.e. bytecode placed at a specific
// address), but the same rationale for excluding them applies so we include those too.
// These are reserved by Ethereum and may be on all EVM-compatible chains.
vm.assume(addr < address(0x1) || addr > address(0xff));
// forgefmt: disable-start
if (chainId == 10 || chainId == 420 || chainId == 11155420) {
// https://github.com/ethereum-optimism/optimism/blob/eaa371a0184b56b7ca6d9eb9cb0a2b78b2ccd864/op-bindings/predeploys/addresses.go#L6-L21
vm.assume(addr < address(0x4200000000000000000000000000000000000000) || addr > address(0x4200000000000000000000000000000000000800));
} else if (chainId == 42161 || chainId == 421613) {
// https://developer.arbitrum.io/useful-addresses#arbitrum-precompiles-l2-same-on-all-arb-chains
vm.assume(addr < address(0x0000000000000000000000000000000000000064) || addr > address(0x0000000000000000000000000000000000000068));
} else if (chainId == 43114 || chainId == 43113) {
// https://github.com/ava-labs/subnet-evm/blob/47c03fd007ecaa6de2c52ea081596e0a88401f58/precompile/params.go#L18-L59
vm.assume(addr < address(0x0100000000000000000000000000000000000000) || addr > address(0x01000000000000000000000000000000000000ff));
vm.assume(addr < address(0x0200000000000000000000000000000000000000) || addr > address(0x02000000000000000000000000000000000000FF));
vm.assume(addr < address(0x0300000000000000000000000000000000000000) || addr > address(0x03000000000000000000000000000000000000Ff));
}
// forgefmt: disable-end
}
/// @notice Assumes `addr` is not a Forge-reserved address (vm, console, Create2Deployer), skipping the fuzz run if it is.
function assumeNotForgeAddress(address addr) internal pure virtual {
// vm, console, and Create2Deployer addresses
vm.assume(
addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
&& addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
);
}
/// @notice Assumes `addr` has no code and is not a precompile, zero, or Forge-reserved address.
function assumeUnusedAddress(address addr) internal view virtual {
uint256 size;
assembly {
size := extcodesize(addr)
}
vm.assume(size == 0);
assumeNotPrecompile(addr);
assumeNotZeroAddress(addr);
assumeNotForgeAddress(addr);
}
/// @notice Reads and parses an EIP-1559 broadcast artifact from `path`.
function readEIP1559ScriptArtifact(string memory path)
internal
view
virtual
returns (EIP1559ScriptArtifact memory)
{
string memory data = vm.readFile(path);
bytes memory parsedData = vm.parseJson(data);
RawEIP1559ScriptArtifact memory rawArtifact = abi.decode(parsedData, (RawEIP1559ScriptArtifact));
EIP1559ScriptArtifact memory artifact;
artifact.libraries = rawArtifact.libraries;
artifact.path = rawArtifact.path;
artifact.timestamp = rawArtifact.timestamp;
artifact.pending = rawArtifact.pending;
artifact.txReturns = rawArtifact.txReturns;
artifact.receipts = rawToConvertedReceipts(rawArtifact.receipts);
artifact.transactions = rawToConvertedEIPTx1559s(rawArtifact.transactions);
return artifact;
}
/// @notice Converts an array of raw EIP-1559 transactions to the user-friendly `Tx1559` format.
function rawToConvertedEIPTx1559s(RawTx1559[] memory rawTxs) internal pure virtual returns (Tx1559[] memory) {
Tx1559[] memory txs = new Tx1559[](rawTxs.length);
for (uint256 i; i < rawTxs.length; i++) {
txs[i] = rawToConvertedEIPTx1559(rawTxs[i]);
}
return txs;
}
/// @notice Converts a single raw EIP-1559 transaction to the user-friendly `Tx1559` format.
function rawToConvertedEIPTx1559(RawTx1559 memory rawTx) internal pure virtual returns (Tx1559 memory) {
Tx1559 memory transaction;
transaction.arguments = rawTx.arguments;
transaction.contractAddress = rawTx.contractAddress;
transaction.contractName = rawTx.contractName;
transaction.functionSig = rawTx.functionSig;
transaction.hash = rawTx.hash;
transaction.txDetail = rawToConvertedEIP1559Detail(rawTx.txDetail);
transaction.opcode = rawTx.opcode;
return transaction;
}
/// @notice Converts raw EIP-1559 transaction detail fields to the user-friendly `Tx1559Detail` format.
function rawToConvertedEIP1559Detail(RawTx1559Detail memory rawDetail)
internal
pure
virtual
returns (Tx1559Detail memory)
{
Tx1559Detail memory txDetail;
txDetail.data = rawDetail.data;
txDetail.from = rawDetail.from;
txDetail.to = rawDetail.to;
txDetail.nonce = _bytesToUint(rawDetail.nonce);
txDetail.txType = _bytesToUint(rawDetail.txType);
txDetail.value = _bytesToUint(rawDetail.value);
txDetail.gas = _bytesToUint(rawDetail.gas);
txDetail.accessList = rawDetail.accessList;
return txDetail;
}
/// @notice Reads all EIP-1559 transactions from the broadcast artifact at `path`.
function readTx1559s(string memory path) internal view virtual returns (Tx1559[] memory) {
string memory deployData = vm.readFile(path);
bytes memory parsedDeployData = vm.parseJson(deployData, ".transactions");
RawTx1559[] memory rawTxs = abi.decode(parsedDeployData, (RawTx1559[]));
return rawToConvertedEIPTx1559s(rawTxs);
}
/// @notice Reads the EIP-1559 transaction at `index` from the broadcast artifact at `path`.
function readTx1559(string memory path, uint256 index) internal view virtual returns (Tx1559 memory) {
string memory deployData = vm.readFile(path);
string memory key = string(abi.encodePacked(".transactions[", vm.toString(index), "]"));
bytes memory parsedDeployData = vm.parseJson(deployData, key);
RawTx1559 memory rawTx = abi.decode(parsedDeployData, (RawTx1559));
return rawToConvertedEIPTx1559(rawTx);
}
/// @notice Reads all transaction receipts from the broadcast artifact at `path`.
function readReceipts(string memory path) internal view virtual returns (Receipt[] memory) {
string memory deployData = vm.readFile(path);
bytes memory parsedDeployData = vm.parseJson(deployData, ".receipts");
RawReceipt[] memory rawReceipts = abi.decode(parsedDeployData, (RawReceipt[]));
return rawToConvertedReceipts(rawReceipts);
}
/// @notice Reads the transaction receipt at `index` from the broadcast artifact at `path`.
function readReceipt(string memory path, uint256 index) internal view virtual returns (Receipt memory) {
string memory deployData = vm.readFile(path);
string memory key = string(abi.encodePacked(".receipts[", vm.toString(index), "]"));
bytes memory parsedDeployData = vm.parseJson(deployData, key);
RawReceipt memory rawReceipt = abi.decode(parsedDeployData, (RawReceipt));
return rawToConvertedReceipt(rawReceipt);
}
/// @notice Converts an array of raw receipts to the user-friendly `Receipt` format.
function rawToConvertedReceipts(RawReceipt[] memory rawReceipts) internal pure virtual returns (Receipt[] memory) {
Receipt[] memory receipts = new Receipt[](rawReceipts.length);
for (uint256 i; i < rawReceipts.length; i++) {
receipts[i] = rawToConvertedReceipt(rawReceipts[i]);
}
return receipts;
}
/// @notice Converts a single raw receipt to the user-friendly `Receipt` format.
function rawToConvertedReceipt(RawReceipt memory rawReceipt) internal pure virtual returns (Receipt memory) {
Receipt memory receipt;
receipt.blockHash = rawReceipt.blockHash;
receipt.to = rawReceipt.to;
receipt.from = rawReceipt.from;
receipt.contractAddress = rawReceipt.contractAddress;
receipt.effectiveGasPrice = _bytesToUint(rawReceipt.effectiveGasPrice);
receipt.cumulativeGasUsed = _bytesToUint(rawReceipt.cumulativeGasUsed);
receipt.gasUsed = _bytesToUint(rawReceipt.gasUsed);
receipt.status = _bytesToUint(rawReceipt.status);
receipt.transactionIndex = _bytesToUint(rawReceipt.transactionIndex);
receipt.blockNumber = _bytesToUint(rawReceipt.blockNumber);
receipt.logs = rawToConvertedReceiptLogs(rawReceipt.logs);
receipt.logsBloom = rawReceipt.logsBloom;
receipt.transactionHash = rawReceipt.transactionHash;
return receipt;
}
/// @notice Converts an array of raw receipt logs to the user-friendly `ReceiptLog` format.
function rawToConvertedReceiptLogs(RawReceiptLog[] memory rawLogs)
internal
pure
virtual
returns (ReceiptLog[] memory)
{
ReceiptLog[] memory logs = new ReceiptLog[](rawLogs.length);
for (uint256 i; i < rawLogs.length; i++) {
logs[i].logAddress = rawLogs[i].logAddress;
logs[i].blockHash = rawLogs[i].blockHash;
logs[i].blockNumber = _bytesToUint(rawLogs[i].blockNumber);
logs[i].data = rawLogs[i].data;
logs[i].logIndex = _bytesToUint(rawLogs[i].logIndex);
logs[i].topics = rawLogs[i].topics;
logs[i].transactionIndex = _bytesToUint(rawLogs[i].transactionIndex);
logs[i].transactionLogIndex = _bytesToUint(rawLogs[i].transactionLogIndex);
logs[i].removed = rawLogs[i].removed;
}
return logs;
}
/// @notice Deploys a contract from the artifacts directory with ABI-encoded constructor arguments.
function deployCode(string memory what, bytes memory args) internal virtual returns (address addr) {
bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
assembly ("memory-safe") {
addr := create(0, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string,bytes): Deployment failed.");
}
/// @notice Deploys a contract from the artifacts directory.
function deployCode(string memory what) internal virtual returns (address addr) {
bytes memory bytecode = vm.getCode(what);
assembly ("memory-safe") {
addr := create(0, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string): Deployment failed.");
}
/// @notice Deploys a contract from the artifacts directory with ABI-encoded constructor arguments, sending `val` wei on construction.
function deployCode(string memory what, bytes memory args, uint256 val) internal virtual returns (address addr) {
bytes memory bytecode = abi.encodePacked(vm.getCode(what), args);
assembly ("memory-safe") {
addr := create(val, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string,bytes,uint256): Deployment failed.");
}
/// @notice Deploys a contract from the artifacts directory, sending `val` wei on construction.
function deployCode(string memory what, uint256 val) internal virtual returns (address addr) {
bytes memory bytecode = vm.getCode(what);
assembly ("memory-safe") {
addr := create(val, add(bytecode, 0x20), mload(bytecode))
}
require(addr != address(0), "StdCheats deployCode(string,uint256): Deployment failed.");
}
/// @notice Creates a labeled address and the corresponding private key derived from `name`.
function makeAddrAndKey(string memory name) internal virtual returns (address addr, uint256 privateKey) {
privateKey = uint256(keccak256(abi.encodePacked(name)));
addr = vm.addr(privateKey);
vm.label(addr, name);
}
/// @notice Creates a labeled address derived from `name`.
function makeAddr(string memory name) internal virtual returns (address addr) {
(addr,) = makeAddrAndKey(name);
}
/// @notice Immediately destroys `who`, zeroing its balance, code, and nonce, and sending its balance to `beneficiary`.
/// @dev Unlike `selfdestruct`, this takes effect immediately within the same transaction.
function destroyAccount(address who, address beneficiary) internal virtual {
uint256 currBalance = who.balance;
vm.etch(who, abi.encode());
vm.deal(who, 0);
vm.resetNonce(who);
uint256 beneficiaryBalance = beneficiary.balance;
vm.deal(beneficiary, currBalance + beneficiaryBalance);
}
/// @notice Creates an `Account` struct with a labeled address and private key derived from `name`.
function makeAccount(string memory name) internal virtual returns (Account memory account) {
(account.addr, account.key) = makeAddrAndKey(name);
}
/// @notice Derives a private key from `mnemonic` at `index`, stores it in the local wallet, and returns the address and key.
function deriveRememberKey(string memory mnemonic, uint32 index)
internal
virtual
returns (address who, uint256 privateKey)
{
privateKey = vm.deriveKey(mnemonic, index);
who = vm.rememberKey(privateKey);
}
function _bytesToUint(bytes memory b) private pure returns (uint256) {
require(b.length <= 32, "StdCheats _bytesToUint(bytes): Bytes length exceeds 32.");
return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
}
/// @notice Returns whether the current test environment is running against a forked network.
function isFork() internal view virtual returns (bool status) {
try vm.activeFork() {
status = true;
} catch (bytes memory) {}
}
/// @notice Skips the test body when running against a forked network.
modifier skipWhenForking() {
if (!isFork()) {
_;
}
}
/// @notice Skips the test body when not running against a forked network.
modifier skipWhenNotForking() {
if (isFork()) {
_;
}
}
/// @notice Disables gas metering for the duration of the function, re-enabling it on exit.
/// @dev When nested, gas metering is only resumed at the end of the outermost function that uses this modifier.
modifier noGasMetering() {
vm.pauseGasMetering();
// To prevent turning gas monitoring back on with nested functions that use this modifier,
// we check if gasMetering started in the off position. If it did, we don't want to turn
// it back on until we exit the top level function that used the modifier
//
// i.e. funcA() noGasMetering { funcB() }, where funcB has noGasMetering as well.
// funcA will have `gasStartedOff` as false, funcB will have it as true,
// so we only turn metering back on at the end of the funcA
bool gasStartedOff = _gasMeteringOff;
_gasMeteringOff = true;
_;
// if gas metering was on when this modifier was called, turn it back on at the end
if (!gasStartedOff) {
_gasMeteringOff = false;
vm.resumeGasMetering();
}
}
// We use this complex approach of `_viewChainId` and `_pureChainId` to ensure there are no
// compiler warnings when accessing chain ID in any solidity version supported by forge-std. We
// can't simply access the chain ID in a normal view or pure function because the solc View Pure
// Checker changed `chainid` from pure to view in 0.8.0.
function _viewChainId() private view returns (uint256 chainId) {
// Assembly required since `block.chainid` was introduced in 0.8.0.
assembly {
chainId := chainid()
}
address(this); // Silence warnings in older Solc versions.
}
function _pureChainId() private pure returns (uint256 chainId) {
function() internal view returns (uint256) fnIn = _viewChainId;
function() internal pure returns (uint256) pureChainId;
assembly {
pureChainId := fnIn
}
chainId = pureChainId();
}
}
// Wrappers around cheatcodes to avoid footguns
abstract contract StdCheats is StdCheatsSafe {
using stdStorage for StdStorage;
StdStorage private _stdstore;
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
address private constant _CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
/// @notice Advances the block timestamp forward by `time` seconds.
function skip(uint256 time) internal virtual {
vm.warp(vm.getBlockTimestamp() + time);
}
/// @notice Rewinds the block timestamp backward by `time` seconds.
function rewind(uint256 time) internal virtual {
vm.warp(vm.getBlockTimestamp() - time);
}
/// @notice Sets up a single-call prank from `msgSender`, giving it `2**128` wei.
function hoax(address msgSender) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.prank(msgSender);
}
/// @notice Sets up a single-call prank from `msgSender`, giving it `give` wei.
function hoax(address msgSender, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.prank(msgSender);
}
/// @notice Sets up a single-call prank from `msgSender` with `origin` as `tx.origin`, giving `msgSender` `2**128` wei.
function hoax(address msgSender, address origin) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.prank(msgSender, origin);
}
/// @notice Sets up a single-call prank from `msgSender` with `origin` as `tx.origin`, giving `msgSender` `give` wei.
function hoax(address msgSender, address origin, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.prank(msgSender, origin);
}
/// @notice Starts a persistent prank from `msgSender`, giving it `2**128` wei.
function startHoax(address msgSender) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.startPrank(msgSender);
}
/// @notice Starts a persistent prank from `msgSender`, giving it `give` wei.
function startHoax(address msgSender, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.startPrank(msgSender);
}
/// @notice Starts a persistent prank from `msgSender` with `origin` as `tx.origin`, giving `msgSender` `2**128` wei.
function startHoax(address msgSender, address origin) internal virtual {
vm.deal(msgSender, 1 << 128);
vm.startPrank(msgSender, origin);
}
/// @notice Starts a persistent prank from `msgSender` with `origin` as `tx.origin`, giving `msgSender` `give` wei.
function startHoax(address msgSender, address origin, uint256 give) internal virtual {
vm.deal(msgSender, give);
vm.startPrank(msgSender, origin);
}
/// @notice Changes the active prank to `msgSender`.
/// @dev Deprecated. Use `vm.startPrank` instead.
function changePrank(address msgSender) internal virtual {
_console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
vm.stopPrank();
vm.startPrank(msgSender);
}
/// @notice Changes the active prank to `msgSender` with `txOrigin` as `tx.origin`.
/// @dev Deprecated. Use `vm.startPrank` instead.
function changePrank(address msgSender, address txOrigin) internal virtual {
_console2_log_StdCheats("changePrank is deprecated. Please use vm.startPrank instead.");
vm.stopPrank();
vm.startPrank(msgSender, txOrigin);
}
/// @notice Expects a call to `callee` with `data` and mocks it to return `returnData`.
function expectAndMockCall(address callee, bytes memory data, bytes memory returnData) internal virtual {
vm.expectCall(callee, data);
vm.mockCall(callee, data, returnData);
}
/// @notice Expects exactly `count` calls to `callee` with `data` and mocks them to return `returnData`.
function expectAndMockCall(address callee, bytes memory data, uint64 count, bytes memory returnData)
internal
virtual
{
vm.expectCall(callee, data, count);
vm.mockCall(callee, data, returnData);
}
/// @notice Expects a call to `callee` with `msgValue` and `data` and mocks it to return `returnData`.
function expectAndMockCall(address callee, uint256 msgValue, bytes memory data, bytes memory returnData)
internal
virtual
{
vm.expectCall(callee, msgValue, data);
vm.mockCall(callee, msgValue, data, returnData);
}
/// @notice Expects exactly `count` calls to `callee` with `msgValue` and `data` and mocks them to return `returnData`.
function expectAndMockCall(
address callee,
uint256 msgValue,
bytes memory data,
uint64 count,
bytes memory returnData
) internal virtual {
vm.expectCall(callee, msgValue, data, count);
vm.mockCall(callee, msgValue, data, returnData);
}
/// @notice Expects a call to `callee` with `msgValue` and `data` forwarding `gas`, and mocks it to return `returnData`.
/// @dev `gas` only applies to the call expectation; the mock call ignores `gas`.
function expectAndMockCall(address callee, uint256 msgValue, uint64 gas, bytes memory data, bytes memory returnData)
internal
virtual
{
vm.expectCall(callee, msgValue, gas, data);
vm.mockCall(callee, msgValue, data, returnData);
}
/// @notice Expects exactly `count` calls to `callee` with `msgValue` and `data` forwarding `gas`, and mocks them to return `returnData`.
/// @dev `gas` only applies to the call expectation; the mock call ignores `gas`.
function expectAndMockCall(
address callee,
uint256 msgValue,
uint64 gas,
bytes memory data,
uint64 count,
bytes memory returnData
) internal virtual {
vm.expectCall(callee, msgValue, gas, data, count);
vm.mockCall(callee, msgValue, data, returnData);
}
/// @notice Sets the ETH balance of `to` to `give`.
function deal(address to, uint256 give) internal virtual {
vm.deal(to, give);
}
/// @notice Sets the ERC20 `token` balance of `to` to `give`.
function deal(address token, address to, uint256 give) internal virtual {
deal(token, to, give, false);
}
/// @notice Sets the ERC1155 `token` balance of `to` for token `id` to `give`.
function dealERC1155(address token, address to, uint256 id, uint256 give) internal virtual {
dealERC1155(token, to, id, give, false);
}
/// @notice Sets the ERC20 `token` balance of `to` to `give`, optionally adjusting the total supply.
function deal(address token, address to, uint256 give, bool adjust) internal virtual {
// get current balance
(, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
uint256 prevBal = abi.decode(balData, (uint256));
// update balance
_stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(give);
// update total supply
if (adjust) {
(, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0x18160ddd));
uint256 totSup = abi.decode(totSupData, (uint256));
if (give < prevBal) {
totSup -= (prevBal - give);
} else {
totSup += (give - prevBal);
}
_stdstore.target(token).sig(0x18160ddd).checked_write(totSup);
}
}
/// @notice Sets the ERC1155 `token` balance of `to` for token `id` to `give`, optionally adjusting the total supply.
function dealERC1155(address token, address to, uint256 id, uint256 give, bool adjust) internal virtual {
// get current balance
(, bytes memory balData) = token.staticcall(abi.encodeWithSelector(0x00fdd58e, to, id));
uint256 prevBal = abi.decode(balData, (uint256));
// update balance
_stdstore.target(token).sig(0x00fdd58e).with_key(to).with_key(id).checked_write(give);
// update total supply
if (adjust) {
(, bytes memory totSupData) = token.staticcall(abi.encodeWithSelector(0xbd85b039, id));
require(
totSupData.length != 0,
"StdCheats dealERC1155(address,address,uint256,uint256,bool): target contract is not ERC1155Supply."
);
uint256 totSup = abi.decode(totSupData, (uint256));
if (give < prevBal) {
totSup -= (prevBal - give);
} else {
totSup += (give - prevBal);
}
_stdstore.target(token).sig(0xbd85b039).with_key(id).checked_write(totSup);
}
}
/// @notice Transfers ownership of ERC721 `token` with `id` to `to`, updating balances accordingly.
function dealERC721(address token, address to, uint256 id) internal virtual {
// check if token id is already minted and the actual owner.
(bool successMinted, bytes memory ownerData) = token.staticcall(abi.encodeWithSelector(0x6352211e, id));
require(successMinted, "StdCheats dealERC721(address,address,uint256): id not minted.");
// get owner current balance
(, bytes memory fromBalData) =
token.staticcall(abi.encodeWithSelector(0x70a08231, abi.decode(ownerData, (address))));
uint256 fromPrevBal = abi.decode(fromBalData, (uint256));
// get new user current balance
(, bytes memory toBalData) = token.staticcall(abi.encodeWithSelector(0x70a08231, to));
uint256 toPrevBal = abi.decode(toBalData, (uint256));
// update balances
_stdstore.target(token).sig(0x70a08231).with_key(abi.decode(ownerData, (address))).checked_write(--fromPrevBal);
_stdstore.target(token).sig(0x70a08231).with_key(to).checked_write(++toPrevBal);
// update owner
_stdstore.target(token).sig(0x6352211e).with_key(id).checked_write(to);
}
/// @notice Etches the runtime bytecode of `what` (from the artifacts directory) at `where`.
/// @dev Runs the contract's creation code via `vm.etch` + a self-call, then etches the resulting runtime code at `where`. Constructor side-effects on other contracts are not preserved.
function deployCodeTo(string memory what, address where) internal virtual {
deployCodeTo(what, "", 0, where);
}
/// @notice Etches the runtime bytecode of `what` (from the artifacts directory) at `where`, using `args` as ABI-encoded constructor arguments.
/// @dev Runs the contract's creation code via `vm.etch` + a self-call, then etches the resulting runtime code at `where`. Constructor side-effects on other contracts are not preserved.
function deployCodeTo(string memory what, bytes memory args, address where) internal virtual {
deployCodeTo(what, args, 0, where);
}
/// @notice Etches the runtime bytecode of `what` (from the artifacts directory) at `where`, using `args` as ABI-encoded constructor arguments and sending `value` wei to the constructor.
/// @dev Runs the contract's creation code via `vm.etch` + a self-call, then etches the resulting runtime code at `where`. Constructor side-effects on other contracts are not preserved.
function deployCodeTo(string memory what, bytes memory args, uint256 value, address where) internal virtual {
bytes memory creationCode = vm.getCode(what);
vm.etch(where, abi.encodePacked(creationCode, args));
(bool success, bytes memory runtimeBytecode) = where.call{value: value}("");
require(success, "StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
vm.etch(where, runtimeBytecode);
}
// Used to prevent the compilation of console, which shortens the compilation time when console is not used elsewhere.
function _console2_log_StdCheats(string memory p0) private view {
(bool status,) = address(_CONSOLE2_ADDRESS).staticcall(abi.encodeWithSignature("log(string)", p0));
status;
}
}

632
packages/contracts/lib/forge-std/src/StdConfig.sol Normal file
View file

@ -0,0 +1,632 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.13;
import {VmSafe} from "./Vm.sol";
import {Variable, Type, TypeKind, LibVariable} from "./LibVariable.sol";
/// @notice A contract that parses a toml configuration file and loads its
/// variables into storage, automatically casting them, on deployment.
///
/// @dev This contract assumes a toml structure where top-level keys
/// represent chain ids or aliases. Under each chain key, variables are
/// organized by type in separate sub-tables like `[<chain>.<type>]`, where
/// type must be: `bool`, `address`, `bytes32`, `uint`, `int`, `string`, or `bytes`.
///
/// Supported format:
/// ```
/// [mainnet]
/// endpoint_url = "${MAINNET_RPC}"
///
/// [mainnet.bool]
/// is_live = true
///
/// [mainnet.address]
/// weth = "0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2"
/// whitelisted_admins = [
/// "${MAINNET_ADMIN}",
/// "0x00000000000000000000000000000000deadbeef",
/// "0x000000000000000000000000000000c0ffeebabe"
/// ]
///
/// [mainnet.uint]
/// important_number = 123
/// ```
contract StdConfig {
using LibVariable for Type;
using LibVariable for TypeKind;
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
/// @dev Types: `bool`, `address`, `bytes32`, `uint`, `int`, `string`, `bytes`.
uint8 private constant _NUM_TYPES = 7;
// -- ERRORS ---------------------------------------------------------------
error AlreadyInitialized(string key);
error InvalidChainKey(string aliasOrId);
error ChainNotInitialized(uint256 chainId);
error UnableToParseVariable(string key);
error WriteToFileInForbiddenCtxt();
// -- STORAGE (CACHE FROM CONFIG FILE) ------------------------------------
/// @dev Path to the loaded TOML configuration file.
string private _filePath;
/// @dev List of top-level keys found in the TOML file, assumed to be chain names/aliases.
string[] private _chainKeys;
/// @dev Storage for the configured RPC URL for each chain.
mapping(uint256 => string) private _rpcOf;
/// @dev Storage for values, organized by chain ID and variable key.
mapping(uint256 => mapping(string => bytes)) private _dataOf;
/// @dev Type cache for runtime checking when casting.
mapping(uint256 => mapping(string => Type)) private _typeOf;
/// @dev When enabled, `set` will always write updates back to the configuration file.
/// Can only be enabled in a scripting context to prevent file corruption from
/// concurrent I/O access, as tests run in parallel.
bool private _writeToFile;
// -- CONSTRUCTOR ----------------------------------------------------------
/// @notice Reads the TOML file and iterates through each top-level key, which is
/// assumed to be a chain name or ID. For each chain, it caches its RPC
/// endpoint and all variables defined in typed sub-tables like `[<chain>.<type>]`,
/// where type must be: `bool`, `address`, `bytes32`, `uint`, `int`, `string`, or `bytes`.
///
/// The constructor attempts to parse each variable first as a single value,
/// and if that fails, as an array of that type. If a variable cannot be
/// parsed as either, the constructor will revert with an error.
///
/// @param configFilePath: The local path to the TOML configuration file.
/// @param writeToFile: Whether to write updates back to the TOML file. Only for scripts.
constructor(string memory configFilePath, bool writeToFile) {
if (writeToFile && !vm.isContext(VmSafe.ForgeContext.ScriptGroup)) {
revert WriteToFileInForbiddenCtxt();
}
_filePath = configFilePath;
_writeToFile = writeToFile;
string memory content = vm.resolveEnv(vm.readFile(configFilePath));
string[] memory chain_keys = vm.parseTomlKeys(content, "$");
// Cache the entire configuration to storage
for (uint256 i = 0; i < chain_keys.length; i++) {
string memory chain_key = chain_keys[i];
// Ignore top-level keys that are not tables
if (vm.parseTomlKeys(content, string.concat("$.", chain_key)).length == 0) {
continue;
}
uint256 chainId = resolveChainId(chain_key);
_chainKeys.push(chain_key);
// Cache the configured RPC endpoint for that chain.
// Falls back to `[rpc_endpoints]`. Panics if no rpc endpoint is configured.
try vm.parseTomlString(content, string.concat("$.", chain_key, ".endpoint_url")) returns (
string memory url
) {
_rpcOf[chainId] = vm.resolveEnv(url);
} catch {
_rpcOf[chainId] = vm.resolveEnv(vm.rpcUrl(chain_key));
}
// Iterate through all the available `TypeKind`s (except `None`) to create the sub-section paths
for (uint8 t = 1; t <= _NUM_TYPES; t++) {
TypeKind ty = TypeKind(t);
string memory typePath = string.concat("$.", chain_key, ".", ty.toTomlKey());
try vm.parseTomlKeys(content, typePath) returns (string[] memory keys) {
for (uint256 j = 0; j < keys.length; j++) {
string memory key = keys[j];
if (_typeOf[chainId][key].kind == TypeKind.None) {
_loadAndCacheValue(content, string.concat(typePath, ".", key), chainId, key, ty);
} else {
revert AlreadyInitialized(key);
}
}
} catch {}
}
}
}
function _loadAndCacheValue(
string memory content,
string memory path,
uint256 chainId,
string memory key,
TypeKind ty
) private {
bool success = false;
if (ty == TypeKind.Bool) {
try vm.parseTomlBool(content, path) returns (bool val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Bool, false);
success = true;
} catch {
try vm.parseTomlBoolArray(content, path) returns (bool[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Bool, true);
success = true;
} catch {}
}
} else if (ty == TypeKind.Address) {
try vm.parseTomlAddress(content, path) returns (address val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Address, false);
success = true;
} catch {
try vm.parseTomlAddressArray(content, path) returns (address[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Address, true);
success = true;
} catch {}
}
} else if (ty == TypeKind.Bytes32) {
try vm.parseTomlBytes32(content, path) returns (bytes32 val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Bytes32, false);
success = true;
} catch {
try vm.parseTomlBytes32Array(content, path) returns (bytes32[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Bytes32, true);
success = true;
} catch {}
}
} else if (ty == TypeKind.Uint256) {
try vm.parseTomlUint(content, path) returns (uint256 val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Uint256, false);
success = true;
} catch {
try vm.parseTomlUintArray(content, path) returns (uint256[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Uint256, true);
success = true;
} catch {}
}
} else if (ty == TypeKind.Int256) {
try vm.parseTomlInt(content, path) returns (int256 val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Int256, false);
success = true;
} catch {
try vm.parseTomlIntArray(content, path) returns (int256[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Int256, true);
success = true;
} catch {}
}
} else if (ty == TypeKind.Bytes) {
try vm.parseTomlBytes(content, path) returns (bytes memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Bytes, false);
success = true;
} catch {
try vm.parseTomlBytesArray(content, path) returns (bytes[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.Bytes, true);
success = true;
} catch {}
}
} else if (ty == TypeKind.String) {
try vm.parseTomlString(content, path) returns (string memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.String, false);
success = true;
} catch {
try vm.parseTomlStringArray(content, path) returns (string[] memory val) {
_dataOf[chainId][key] = abi.encode(val);
_typeOf[chainId][key] = Type(TypeKind.String, true);
success = true;
} catch {}
}
}
if (!success) {
revert UnableToParseVariable(key);
}
}
// -- HELPER FUNCTIONS -----------------------------------------------------
/// @notice Enable or disable automatic writing to the TOML file on `set`.
/// Can only be enabled when scripting.
function writeUpdatesBackToFile(bool enabled) public {
if (enabled && !vm.isContext(VmSafe.ForgeContext.ScriptGroup)) {
revert WriteToFileInForbiddenCtxt();
}
_writeToFile = enabled;
}
/// @notice Resolves a chain alias or a chain id string to its numerical chain id.
/// @param aliasOrId The string representing the chain alias (i.e. "mainnet") or a numerical ID (i.e. "1").
/// @return The numerical chain ID.
/// @dev It first attempts to parse the input as a number. If that fails, it uses `vm.getChain` to resolve a named alias.
/// Reverts if the alias is not valid or not a number.
function resolveChainId(string memory aliasOrId) public view returns (uint256) {
try vm.parseUint(aliasOrId) returns (uint256 chainId) {
return chainId;
} catch {
try vm.getChain(aliasOrId) returns (VmSafe.Chain memory chainInfo) {
return chainInfo.chainId;
} catch {
revert InvalidChainKey(aliasOrId);
}
}
}
/// @dev Retrieves the chain key/alias from the configuration based on the chain ID.
function _getChainKeyFromId(uint256 chainId) private view returns (string memory) {
for (uint256 i = 0; i < _chainKeys.length; i++) {
if (resolveChainId(_chainKeys[i]) == chainId) {
return _chainKeys[i];
}
}
revert ChainNotInitialized(chainId);
}
/// @dev Ensures type consistency when setting a value - prevents changing types unless uninitialized.
/// Updates type only when the previous type was `None`.
function _ensureTypeConsistency(uint256 chainId, string memory key, Type memory ty) private {
Type memory current = _typeOf[chainId][key];
if (current.kind == TypeKind.None) {
_typeOf[chainId][key] = ty;
} else {
current.assertEq(ty);
}
}
/// @dev Wraps a string in double quotes for JSON compatibility.
function _quote(string memory s) private pure returns (string memory) {
return string.concat('"', s, '"');
}
/// @dev Writes a JSON-formatted value to a specific key in the TOML file.
/// @param chainId The chain id to write under.
/// @param ty The type category ('bool', 'address', 'uint', 'bytes32', 'string', or 'bytes').
/// @param key The variable key name.
/// @param jsonValue The JSON-formatted value to write.
function _writeToToml(uint256 chainId, string memory ty, string memory key, string memory jsonValue) private {
string memory chainKey = _getChainKeyFromId(chainId);
string memory valueKey = string.concat("$.", chainKey, ".", ty, ".", key);
vm.writeToml(jsonValue, _filePath, valueKey);
}
// -- GETTER FUNCTIONS -----------------------------------------------------
/// @dev Reads a variable for a given chain id and key, and returns it in a generic container.
/// The caller should use `LibVariable` to safely coerce the type.
/// Example: `uint256 myVar = config.get("my_key").toUint256();`
///
/// @param chain_id The chain ID to read from.
/// @param key The key of the variable to retrieve.
/// @return `Variable` struct containing the type and the ABI-encoded value.
function get(uint256 chain_id, string memory key) public view returns (Variable memory) {
return Variable(_typeOf[chain_id][key], _dataOf[chain_id][key]);
}
/// @dev Reads a variable for the current chain and a given key, and returns it in a generic container.
/// The caller should use `LibVariable` to safely coerce the type.
/// Example: `uint256 myVar = config.get("my_key").toUint256();`
///
/// @param key The key of the variable to retrieve.
/// @return `Variable` struct containing the type and the ABI-encoded value.
function get(string memory key) public view returns (Variable memory) {
return get(vm.getChainId(), key);
}
/// @dev Checks the existence of a variable for a given chain ID and key, and returns a boolean.
/// Example: `bool hasKey = config.exists(1, "my_key");`
///
/// @param chain_id The chain ID to check.
/// @param key The variable key name.
/// @return `bool` indicating whether a variable with the given key exists.
function exists(uint256 chain_id, string memory key) public view returns (bool) {
return _dataOf[chain_id][key].length > 0;
}
/// @dev Checks the existence of a variable for the current chain id and a given key, and returns a boolean.
/// Example: `bool hasKey = config.exists("my_key");`
///
/// @param key The variable key name.
/// @return `bool` indicating whether a variable with the given key exists.
function exists(string memory key) public view returns (bool) {
return exists(vm.getChainId(), key);
}
/// @notice Returns the numerical chain ids for all configured chains.
function getChainIds() public view returns (uint256[] memory) {
string[] memory keys = _chainKeys;
uint256[] memory ids = new uint256[](keys.length);
for (uint256 i = 0; i < keys.length; i++) {
ids[i] = resolveChainId(keys[i]);
}
return ids;
}
/// @notice Reads the RPC URL for a specific chain id.
function getRpcUrl(uint256 chainId) public view returns (string memory) {
return _rpcOf[chainId];
}
/// @notice Reads the RPC URL for the current chain.
function getRpcUrl() public view returns (string memory) {
return _rpcOf[vm.getChainId()];
}
// -- SETTER FUNCTIONS (SINGLE VALUES) -------------------------------------
/// @notice Sets a boolean value for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, bool value) public {
Type memory ty = Type(TypeKind.Bool, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, vm.toString(value));
}
/// @notice Sets a boolean value for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, bool value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets an address value for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, address value) public {
Type memory ty = Type(TypeKind.Address, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, _quote(vm.toString(value)));
}
/// @notice Sets an address value for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, address value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a bytes32 value for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, bytes32 value) public {
Type memory ty = Type(TypeKind.Bytes32, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, _quote(vm.toString(value)));
}
/// @notice Sets a bytes32 value for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, bytes32 value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a uint256 value for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, uint256 value) public {
Type memory ty = Type(TypeKind.Uint256, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, vm.toString(value));
}
/// @notice Sets a uint256 value for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, uint256 value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets an int256 value for a given key and chain ID.
function set(uint256 chainId, string memory key, int256 value) public {
Type memory ty = Type(TypeKind.Int256, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, vm.toString(value));
}
/// @notice Sets an int256 value for a given key on the current chain.
function set(string memory key, int256 value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a string value for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, string memory value) public {
Type memory ty = Type(TypeKind.String, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, _quote(value));
}
/// @notice Sets a string value for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, string memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a bytes value for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, bytes memory value) public {
Type memory ty = Type(TypeKind.Bytes, false);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) _writeToToml(chainId, ty.kind.toTomlKey(), key, _quote(vm.toString(value)));
}
/// @notice Sets a bytes value for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, bytes memory value) public {
set(vm.getChainId(), key, value);
}
// -- SETTER FUNCTIONS (ARRAYS) --------------------------------------------
/// @notice Sets a boolean array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, bool[] memory value) public {
Type memory ty = Type(TypeKind.Bool, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, vm.toString(value[i]));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets a boolean array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, bool[] memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets an address array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, address[] memory value) public {
Type memory ty = Type(TypeKind.Address, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, _quote(vm.toString(value[i])));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets an address array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, address[] memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a bytes32 array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, bytes32[] memory value) public {
Type memory ty = Type(TypeKind.Bytes32, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, _quote(vm.toString(value[i])));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets a bytes32 array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, bytes32[] memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a uint256 array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, uint256[] memory value) public {
Type memory ty = Type(TypeKind.Uint256, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, vm.toString(value[i]));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets a uint256 array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, uint256[] memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a int256 array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, int256[] memory value) public {
Type memory ty = Type(TypeKind.Int256, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, vm.toString(value[i]));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets a int256 array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, int256[] memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a string array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, string[] memory value) public {
Type memory ty = Type(TypeKind.String, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, _quote(value[i]));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets a string array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, string[] memory value) public {
set(vm.getChainId(), key, value);
}
/// @notice Sets a bytes array for a given key and chain ID.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(uint256 chainId, string memory key, bytes[] memory value) public {
Type memory ty = Type(TypeKind.Bytes, true);
_ensureTypeConsistency(chainId, key, ty);
_dataOf[chainId][key] = abi.encode(value);
if (_writeToFile) {
string memory json = "[";
for (uint256 i = 0; i < value.length; i++) {
json = string.concat(json, _quote(vm.toString(value[i])));
if (i < value.length - 1) json = string.concat(json, ",");
}
json = string.concat(json, "]");
_writeToToml(chainId, ty.kind.toTomlKey(), key, json);
}
}
/// @notice Sets a bytes array for a given key on the current chain.
/// @dev Sets the cached value in storage and writes the change back to the TOML file if `autoWrite` is enabled.
function set(string memory key, bytes[] memory value) public {
set(vm.getChainId(), key, value);
}
}

30
packages/contracts/lib/forge-std/src/StdConstants.sol Normal file
View file

@ -0,0 +1,30 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IMulticall3} from "./interfaces/IMulticall3.sol";
import {Vm} from "./Vm.sol";
library StdConstants {
/// @dev Cheat code address.
/// Calculated as `address(uint160(uint256(keccak256("hevm cheat code"))))`.
Vm internal constant VM = Vm(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
/// @dev console.sol and console2.sol work by executing a staticcall to this address.
/// Calculated as `address(uint160(uint88(bytes11("console.log"))))`.
address internal constant CONSOLE = 0x000000000000000000636F6e736F6c652e6c6f67;
/// @dev Used when deploying with create2.
/// Taken from https://github.com/Arachnid/deterministic-deployment-proxy.
address internal constant CREATE2_FACTORY = 0x4e59b44847b379578588920cA78FbF26c0B4956C;
/// @dev The default address for tx.origin and msg.sender.
/// Calculated as `address(uint160(uint256(keccak256("foundry default caller"))))`.
address internal constant DEFAULT_SENDER = 0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38;
/// @dev The address of the first contract `CREATE`d by a running test contract.
/// When running tests, each test contract is `CREATE`d by `DEFAULT_SENDER` with nonce 1.
/// Calculated as `VM.computeCreateAddress(VM.computeCreateAddress(DEFAULT_SENDER, 1), 1)`.
address internal constant DEFAULT_TEST_CONTRACT = 0x5615dEB798BB3E4dFa0139dFa1b3D433Cc23b72f;
/// @dev Deterministic deployment address of the Multicall3 contract.
/// Taken from https://www.multicall3.com.
IMulticall3 internal constant MULTICALL3_ADDRESS = IMulticall3(0xcA11bde05977b3631167028862bE2a173976CA11);
/// @dev The order of the secp256k1 curve.
uint256 internal constant SECP256K1_ORDER =
115792089237316195423570985008687907852837564279074904382605163141518161494337;
}

33
packages/contracts/lib/forge-std/src/StdError.sol Normal file
View file

@ -0,0 +1,33 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
// Panics work for versions >=0.8.0, but we lowered the pragma to make this compatible with Test
pragma solidity >=0.8.13 <0.9.0;
/// @notice Pre-encoded Solidity panic error selectors for use in test assertions.
library stdError {
/// @notice Panic caused by `assert(false)` or an assertion failure (0x01).
bytes public constant assertionError = abi.encodeWithSignature("Panic(uint256)", 0x01);
/// @notice Panic caused by arithmetic overflow or underflow (0x11).
bytes public constant arithmeticError = abi.encodeWithSignature("Panic(uint256)", 0x11);
/// @notice Panic caused by division or modulo by zero (0x12).
bytes public constant divisionError = abi.encodeWithSignature("Panic(uint256)", 0x12);
/// @notice Panic caused by converting a value that is too large or negative into an enum type (0x21).
bytes public constant enumConversionError = abi.encodeWithSignature("Panic(uint256)", 0x21);
/// @notice Panic caused by accessing incorrectly encoded storage data (0x22).
bytes public constant encodeStorageError = abi.encodeWithSignature("Panic(uint256)", 0x22);
/// @notice Panic caused by calling `.pop()` on an empty array (0x31).
bytes public constant popError = abi.encodeWithSignature("Panic(uint256)", 0x31);
/// @notice Panic caused by accessing an array, bytesN, or slice at an out-of-bounds index (0x32).
bytes public constant indexOOBError = abi.encodeWithSignature("Panic(uint256)", 0x32);
/// @notice Panic caused by allocating too much memory or creating an array that is too large (0x41).
bytes public constant memOverflowError = abi.encodeWithSignature("Panic(uint256)", 0x41);
/// @notice Panic caused by calling a zero-initialized variable of internal function type (0x51).
bytes public constant zeroVarError = abi.encodeWithSignature("Panic(uint256)", 0x51);
}

161
packages/contracts/lib/forge-std/src/StdInvariant.sol Normal file
View file

@ -0,0 +1,161 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
/// @notice Abstract contract providing configuration utilities for Forge invariant tests.
abstract contract StdInvariant {
struct FuzzSelector {
address addr;
bytes4[] selectors;
}
struct FuzzArtifactSelector {
string artifact;
bytes4[] selectors;
}
struct FuzzInterface {
address addr;
string[] artifacts;
}
address[] private _excludedContracts;
address[] private _excludedSenders;
address[] private _targetedContracts;
address[] private _targetedSenders;
string[] private _excludedArtifacts;
string[] private _targetedArtifacts;
FuzzArtifactSelector[] private _targetedArtifactSelectors;
FuzzSelector[] private _excludedSelectors;
FuzzSelector[] private _targetedSelectors;
FuzzInterface[] private _targetedInterfaces;
// Functions for users:
// These are intended to be called in tests.
/// @notice Excludes a contract address from invariant target selection.
/// @param newExcludedContract_ The contract address to exclude.
function excludeContract(address newExcludedContract_) internal {
_excludedContracts.push(newExcludedContract_);
}
/// @notice Excludes specific selectors on a contract from invariant fuzzing.
/// @param newExcludedSelector_ The selector configuration to exclude.
function excludeSelector(FuzzSelector memory newExcludedSelector_) internal {
_excludedSelectors.push(newExcludedSelector_);
}
/// @notice Excludes a sender from invariant fuzzing; exclusion takes precedence over targeted senders.
/// @param newExcludedSender_ The sender address to exclude.
function excludeSender(address newExcludedSender_) internal {
_excludedSenders.push(newExcludedSender_);
}
/// @notice Excludes an artifact identifier from invariant target selection.
/// @param newExcludedArtifact_ The artifact identifier to exclude.
function excludeArtifact(string memory newExcludedArtifact_) internal {
_excludedArtifacts.push(newExcludedArtifact_);
}
/// @notice Targets an artifact identifier for invariant fuzzing.
/// @param newTargetedArtifact_ The artifact identifier to target.
function targetArtifact(string memory newTargetedArtifact_) internal {
_targetedArtifacts.push(newTargetedArtifact_);
}
/// @notice Targets specific selectors for an artifact identifier during invariant fuzzing.
/// @param newTargetedArtifactSelector_ The artifact-selector configuration to target.
function targetArtifactSelector(FuzzArtifactSelector memory newTargetedArtifactSelector_) internal {
_targetedArtifactSelectors.push(newTargetedArtifactSelector_);
}
/// @notice Targets a contract address for invariant fuzzing.
/// @param newTargetedContract_ The contract address to target.
function targetContract(address newTargetedContract_) internal {
_targetedContracts.push(newTargetedContract_);
}
/// @notice Targets specific selectors on a contract for invariant fuzzing.
/// @param newTargetedSelector_ The selector configuration to target.
function targetSelector(FuzzSelector memory newTargetedSelector_) internal {
_targetedSelectors.push(newTargetedSelector_);
}
/// @notice Adds a sender to the invariant sender allowlist; when non-empty, fuzzing uses only targeted non-excluded senders.
/// @param newTargetedSender_ The sender address to target.
function targetSender(address newTargetedSender_) internal {
_targetedSenders.push(newTargetedSender_);
}
/// @notice Targets an address plus artifact interfaces for invariant fuzzing.
/// @param newTargetedInterface_ The address-interface configuration to target.
function targetInterface(FuzzInterface memory newTargetedInterface_) internal {
_targetedInterfaces.push(newTargetedInterface_);
}
// Functions for forge:
// These are called by forge to run invariant tests and don't need to be called in tests.
/// @notice Returns artifact identifiers configured via `excludeArtifact`.
/// @return excludedArtifacts_ The list of excluded artifact identifiers.
function excludeArtifacts() public view returns (string[] memory excludedArtifacts_) {
excludedArtifacts_ = _excludedArtifacts;
}
/// @notice Returns contract addresses configured via `excludeContract`.
/// @return excludedContracts_ The list of excluded contract addresses.
function excludeContracts() public view returns (address[] memory excludedContracts_) {
excludedContracts_ = _excludedContracts;
}
/// @notice Returns selector exclusions configured via `excludeSelector`.
/// @return excludedSelectors_ The list of excluded selector configurations.
function excludeSelectors() public view returns (FuzzSelector[] memory excludedSelectors_) {
excludedSelectors_ = _excludedSelectors;
}
/// @notice Returns senders configured via `excludeSender`.
/// @return excludedSenders_ The list of excluded sender addresses.
function excludeSenders() public view returns (address[] memory excludedSenders_) {
excludedSenders_ = _excludedSenders;
}
/// @notice Returns artifact identifiers configured via `targetArtifact`.
/// @return targetedArtifacts_ The list of targeted artifact identifiers.
function targetArtifacts() public view returns (string[] memory targetedArtifacts_) {
targetedArtifacts_ = _targetedArtifacts;
}
/// @notice Returns artifact-selector targets configured via `targetArtifactSelector`.
/// @return targetedArtifactSelectors_ The list of targeted artifact-selector configurations.
function targetArtifactSelectors() public view returns (FuzzArtifactSelector[] memory targetedArtifactSelectors_) {
targetedArtifactSelectors_ = _targetedArtifactSelectors;
}
/// @notice Returns contract addresses configured via `targetContract`.
/// @return targetedContracts_ The list of targeted contract addresses.
function targetContracts() public view returns (address[] memory targetedContracts_) {
targetedContracts_ = _targetedContracts;
}
/// @notice Returns selector targets configured via `targetSelector`.
/// @return targetedSelectors_ The list of targeted selector configurations.
function targetSelectors() public view returns (FuzzSelector[] memory targetedSelectors_) {
targetedSelectors_ = _targetedSelectors;
}
/// @notice Returns sender allowlist configured via `targetSender` (empty means no sender allowlist).
/// @return targetedSenders_ The list of targeted sender addresses.
function targetSenders() public view returns (address[] memory targetedSenders_) {
targetedSenders_ = _targetedSenders;
}
/// @notice Returns address-interface targets configured via `targetInterface`.
/// @return targetedInterfaces_ The list of targeted address-interface configurations.
function targetInterfaces() public view returns (FuzzInterface[] memory targetedInterfaces_) {
targetedInterfaces_ = _targetedInterfaces;
}
}

327
packages/contracts/lib/forge-std/src/StdJson.sol Normal file
View file

@ -0,0 +1,327 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {VmSafe} from "./Vm.sol";
// Helpers for parsing and writing JSON files.
// `key` parameters use the same selector syntax as the `vm.parseJson*` cheatcodes,
// for example `.a` for a nested field or `$` for the root object.
// To parse:
// ```
// using stdJson for string;
// string memory json = vm.readFile("<some_path>");
// uint256 value = json.readUint(".a");
// bytes memory encoded = json.parseRaw("$");
// ```
// To write:
// ```
// using stdJson for string;
// string memory json = "json";
// json.serialize("a", uint256(123));
// string memory semiFinal = json.serialize("b", string("test"));
// string memory finalJson = json.serialize("c", semiFinal);
// finalJson.write("<some_path>");
// ```
library stdJson {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
/// @notice Returns whether `key` exists in `json`.
/// @dev `key` uses the same selector syntax as `vm.parseJson*`, such as `.a` or `$`.
function keyExists(string memory json, string memory key) internal view returns (bool) {
return vm.keyExistsJson(json, key);
}
/// @notice ABI-encodes the JSON value selected by `key`.
/// @dev `key` uses the same selector syntax as `vm.parseJson*`, such as `.a` or `$`.
function parseRaw(string memory json, string memory key) internal pure returns (bytes memory) {
return vm.parseJson(json, key);
}
/// @notice Reads a uint256 value at `key` from `json`.
function readUint(string memory json, string memory key) internal pure returns (uint256) {
return vm.parseJsonUint(json, key);
}
/// @notice Reads a uint256 array at `key` from `json`.
function readUintArray(string memory json, string memory key) internal pure returns (uint256[] memory) {
return vm.parseJsonUintArray(json, key);
}
/// @notice Reads an int256 value at `key` from `json`.
function readInt(string memory json, string memory key) internal pure returns (int256) {
return vm.parseJsonInt(json, key);
}
/// @notice Reads an int256 array at `key` from `json`.
function readIntArray(string memory json, string memory key) internal pure returns (int256[] memory) {
return vm.parseJsonIntArray(json, key);
}
/// @notice Reads a bytes32 value at `key` from `json`.
function readBytes32(string memory json, string memory key) internal pure returns (bytes32) {
return vm.parseJsonBytes32(json, key);
}
/// @notice Reads a bytes32 array at `key` from `json`.
function readBytes32Array(string memory json, string memory key) internal pure returns (bytes32[] memory) {
return vm.parseJsonBytes32Array(json, key);
}
/// @notice Reads a string value at `key` from `json`.
function readString(string memory json, string memory key) internal pure returns (string memory) {
return vm.parseJsonString(json, key);
}
/// @notice Reads a string array at `key` from `json`.
function readStringArray(string memory json, string memory key) internal pure returns (string[] memory) {
return vm.parseJsonStringArray(json, key);
}
/// @notice Reads an address value at `key` from `json`.
function readAddress(string memory json, string memory key) internal pure returns (address) {
return vm.parseJsonAddress(json, key);
}
/// @notice Reads an address array at `key` from `json`.
function readAddressArray(string memory json, string memory key) internal pure returns (address[] memory) {
return vm.parseJsonAddressArray(json, key);
}
/// @notice Reads a bool value at `key` from `json`.
function readBool(string memory json, string memory key) internal pure returns (bool) {
return vm.parseJsonBool(json, key);
}
/// @notice Reads a bool array at `key` from `json`.
function readBoolArray(string memory json, string memory key) internal pure returns (bool[] memory) {
return vm.parseJsonBoolArray(json, key);
}
/// @notice Reads a bytes value at `key` from `json`.
function readBytes(string memory json, string memory key) internal pure returns (bytes memory) {
return vm.parseJsonBytes(json, key);
}
/// @notice Reads a bytes array at `key` from `json`.
function readBytesArray(string memory json, string memory key) internal pure returns (bytes[] memory) {
return vm.parseJsonBytesArray(json, key);
}
/// @notice Reads a uint256 value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readUintOr(string memory json, string memory key, uint256 defaultValue) internal view returns (uint256) {
return keyExists(json, key) ? readUint(json, key) : defaultValue;
}
/// @notice Reads a uint256 array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readUintArrayOr(string memory json, string memory key, uint256[] memory defaultValue)
internal
view
returns (uint256[] memory)
{
return keyExists(json, key) ? readUintArray(json, key) : defaultValue;
}
/// @notice Reads an int256 value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readIntOr(string memory json, string memory key, int256 defaultValue) internal view returns (int256) {
return keyExists(json, key) ? readInt(json, key) : defaultValue;
}
/// @notice Reads an int256 array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readIntArrayOr(string memory json, string memory key, int256[] memory defaultValue)
internal
view
returns (int256[] memory)
{
return keyExists(json, key) ? readIntArray(json, key) : defaultValue;
}
/// @notice Reads a bytes32 value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readBytes32Or(string memory json, string memory key, bytes32 defaultValue)
internal
view
returns (bytes32)
{
return keyExists(json, key) ? readBytes32(json, key) : defaultValue;
}
/// @notice Reads a bytes32 array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readBytes32ArrayOr(string memory json, string memory key, bytes32[] memory defaultValue)
internal
view
returns (bytes32[] memory)
{
return keyExists(json, key) ? readBytes32Array(json, key) : defaultValue;
}
/// @notice Reads a string value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readStringOr(string memory json, string memory key, string memory defaultValue)
internal
view
returns (string memory)
{
return keyExists(json, key) ? readString(json, key) : defaultValue;
}
/// @notice Reads a string array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readStringArrayOr(string memory json, string memory key, string[] memory defaultValue)
internal
view
returns (string[] memory)
{
return keyExists(json, key) ? readStringArray(json, key) : defaultValue;
}
/// @notice Reads an address value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readAddressOr(string memory json, string memory key, address defaultValue)
internal
view
returns (address)
{
return keyExists(json, key) ? readAddress(json, key) : defaultValue;
}
/// @notice Reads an address array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readAddressArrayOr(string memory json, string memory key, address[] memory defaultValue)
internal
view
returns (address[] memory)
{
return keyExists(json, key) ? readAddressArray(json, key) : defaultValue;
}
/// @notice Reads a bool value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readBoolOr(string memory json, string memory key, bool defaultValue) internal view returns (bool) {
return keyExists(json, key) ? readBool(json, key) : defaultValue;
}
/// @notice Reads a bool array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readBoolArrayOr(string memory json, string memory key, bool[] memory defaultValue)
internal
view
returns (bool[] memory)
{
return keyExists(json, key) ? readBoolArray(json, key) : defaultValue;
}
/// @notice Reads a bytes value at `key` from `json`, returning `defaultValue` if the key does not exist.
function readBytesOr(string memory json, string memory key, bytes memory defaultValue)
internal
view
returns (bytes memory)
{
return keyExists(json, key) ? readBytes(json, key) : defaultValue;
}
/// @notice Reads a bytes array at `key` from `json`, returning `defaultValue` if the key does not exist.
function readBytesArrayOr(string memory json, string memory key, bytes[] memory defaultValue)
internal
view
returns (bytes[] memory)
{
return keyExists(json, key) ? readBytesArray(json, key) : defaultValue;
}
/// @notice Serializes a JSON object `rootObject` under `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
return vm.serializeJson(jsonKey, rootObject);
}
/// @notice Serializes a bool `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
return vm.serializeBool(jsonKey, key, value);
}
/// @notice Serializes a bool array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) {
return vm.serializeBool(jsonKey, key, value);
}
/// @notice Serializes a uint256 `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
return vm.serializeUint(jsonKey, key, value);
}
/// @notice Serializes a uint256 array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, uint256[] memory value)
internal
returns (string memory)
{
return vm.serializeUint(jsonKey, key, value);
}
/// @notice Serializes an int256 `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
return vm.serializeInt(jsonKey, key, value);
}
/// @notice Serializes an int256 array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, int256[] memory value)
internal
returns (string memory)
{
return vm.serializeInt(jsonKey, key, value);
}
/// @notice Serializes an address `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
return vm.serializeAddress(jsonKey, key, value);
}
/// @notice Serializes an address array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, address[] memory value)
internal
returns (string memory)
{
return vm.serializeAddress(jsonKey, key, value);
}
/// @notice Serializes a bytes32 `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
return vm.serializeBytes32(jsonKey, key, value);
}
/// @notice Serializes a bytes32 array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
internal
returns (string memory)
{
return vm.serializeBytes32(jsonKey, key, value);
}
/// @notice Serializes a bytes `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
return vm.serializeBytes(jsonKey, key, value);
}
/// @notice Serializes a bytes array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, bytes[] memory value)
internal
returns (string memory)
{
return vm.serializeBytes(jsonKey, key, value);
}
/// @notice Serializes a string `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) {
return vm.serializeString(jsonKey, key, value);
}
/// @notice Serializes a string array `value` under `key` within `jsonKey` and returns the serialized JSON string.
function serialize(string memory jsonKey, string memory key, string[] memory value)
internal
returns (string memory)
{
return vm.serializeString(jsonKey, key, value);
}
/// @notice Writes the serialized JSON object `jsonKey` to `path`.
function write(string memory jsonKey, string memory path) internal {
vm.writeJson(jsonKey, path);
}
/// @notice Writes the value at `valueKey` from the serialized JSON object `jsonKey` to `path`.
function write(string memory jsonKey, string memory path, string memory valueKey) internal {
vm.writeJson(jsonKey, path, valueKey);
}
}

68
packages/contracts/lib/forge-std/src/StdMath.sol Normal file
View file

@ -0,0 +1,68 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
/// @notice Mathematical utility functions for unsigned and signed integers.
library stdMath {
int256 private constant _INT256_MIN =
-57896044618658097711785492504343953926634992332820282019728792003956564819968;
/// @notice Computes the absolute value of a signed integer.
/// @param a The signed integer to compute the absolute value of.
/// @return The absolute value as an unsigned integer.
function abs(int256 a) internal pure returns (uint256) {
// Required or it will fail when `a = type(int256).min`
if (a == _INT256_MIN) {
return 57896044618658097711785492504343953926634992332820282019728792003956564819968;
}
return uint256(a > 0 ? a : -a);
}
/// @notice Computes the absolute difference between two unsigned integers.
/// @param a The first unsigned integer.
/// @param b The second unsigned integer.
/// @return The absolute difference between `a` and `b`.
function delta(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a - b : b - a;
}
/// @notice Computes the absolute difference between two signed integers.
/// @param a The first signed integer.
/// @param b The second signed integer.
/// @return The absolute difference between `a` and `b`.
function delta(int256 a, int256 b) internal pure returns (uint256) {
// a and b are of the same sign
// this works thanks to two's complement, the left-most bit is the sign bit
if ((a ^ b) > -1) {
return delta(abs(a), abs(b));
}
// a and b are of opposite signs
return abs(a) + abs(b);
}
/// @notice Computes the percentage difference between two unsigned integers, scaled by 1e18.
/// @param a The value to compare.
/// @param b The reference value (divisor). Must not be zero.
/// @return The percentage difference scaled by 1e18 (1e18 represents 100%).
function percentDelta(uint256 a, uint256 b) internal pure returns (uint256) {
// Prevent division by zero
require(b != 0, "stdMath percentDelta(uint256,uint256): Divisor is zero");
uint256 absDelta = delta(a, b);
return absDelta * 1e18 / b;
}
/// @notice Computes the percentage difference between two signed integers, scaled by 1e18.
/// @param a The value to compare.
/// @param b The reference value (divisor). Its absolute value must not be zero.
/// @return The percentage difference scaled by 1e18 (1e18 represents 100%).
function percentDelta(int256 a, int256 b) internal pure returns (uint256) {
uint256 absDelta = delta(a, b);
uint256 absB = abs(b);
// Prevent division by zero
require(absB != 0, "stdMath percentDelta(int256,int256): Divisor is zero");
return absDelta * 1e18 / absB;
}
}

521
packages/contracts/lib/forge-std/src/StdStorage.sol Normal file
View file

@ -0,0 +1,521 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Vm} from "./Vm.sol";
struct FindData {
uint256 slot;
uint256 offsetLeft;
uint256 offsetRight;
bool found;
}
struct StdStorage {
mapping(address => mapping(bytes4 => mapping(bytes32 => FindData))) finds;
bytes32[] _keys;
bytes4 _sig;
uint256 _depth;
address _target;
bytes32 _set;
bool _enable_packed_slots;
bytes _calldata;
}
library stdStorageSafe {
event SlotFound(address who, bytes4 fsig, bytes32 keysHash, uint256 slot);
event WARNING_UninitedSlot(address who, uint256 slot);
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
uint256 constant UINT256_MAX = 115792089237316195423570985008687907853269984665640564039457584007913129639935;
/// @notice Returns the 4-byte function selector for `sigStr`.
function sigs(string memory sigStr) internal pure returns (bytes4) {
return bytes4(keccak256(bytes(sigStr)));
}
/// @notice Returns the encoded call parameters (keys or raw calldata) for the configured target function.
function getCallParams(StdStorage storage self) internal view returns (bytes memory) {
if (self._calldata.length == 0) {
return _flatten(self._keys);
} else {
return self._calldata;
}
}
/// @notice Calls the target contract with the configured parameters and returns the success flag and return value.
function callTarget(StdStorage storage self) internal view returns (bool, bytes32) {
bytes memory cd = abi.encodePacked(self._sig, getCallParams(self));
(bool success, bytes memory rdat) = self._target.staticcall(cd);
bytes32 result = _bytesToBytes32(rdat, 32 * self._depth);
return (success, result);
}
/// @notice Returns whether mutating `slot` changes the return value of the configured target call.
/// @dev Temporarily writes either `type(uint256).max` or `0` to the slot to detect sensitivity.
function checkSlotMutatesCall(StdStorage storage self, bytes32 slot) internal returns (bool) {
bytes32 prevSlotValue = vm.load(self._target, slot);
(bool success, bytes32 prevReturnValue) = callTarget(self);
bytes32 testVal = prevReturnValue == bytes32(0) ? bytes32(UINT256_MAX) : bytes32(0);
vm.store(self._target, slot, testVal);
(, bytes32 newReturnValue) = callTarget(self);
vm.store(self._target, slot, prevSlotValue);
return (success && (prevReturnValue != newReturnValue));
}
/// @notice Searches for the bit offset of the packed variable within `slot` from the left or right side.
function findOffset(StdStorage storage self, bytes32 slot, bool left) internal returns (bool, uint256) {
for (uint256 offset = 0; offset < 256; offset++) {
uint256 valueToPut = left ? (1 << (255 - offset)) : (1 << offset);
vm.store(self._target, slot, bytes32(valueToPut));
(bool success, bytes32 data) = callTarget(self);
if (success && (uint256(data) > 0)) {
return (true, offset);
}
}
return (false, 0);
}
/// @notice Returns whether both offsets were found, along with the left and right bit offsets of the packed variable within `slot`.
function findOffsets(StdStorage storage self, bytes32 slot) internal returns (bool, uint256, uint256) {
bytes32 prevSlotValue = vm.load(self._target, slot);
(bool foundLeft, uint256 offsetLeft) = findOffset(self, slot, true);
(bool foundRight, uint256 offsetRight) = findOffset(self, slot, false);
// `findOffset` may mutate slot value, so we are setting it to initial value
vm.store(self._target, slot, prevSlotValue);
return (foundLeft && foundRight, offsetLeft, offsetRight);
}
/// @notice Finds the storage slot for the configured target and returns its data, clearing the configuration.
function find(StdStorage storage self) internal returns (FindData storage) {
return find(self, true);
}
/// @notice find an arbitrary storage slot given a function sig, input data, address of the contract and a value to check against
// slot complexity:
// if flat, will be bytes32(uint256(uint));
// if map, will be keccak256(abi.encode(key, uint(slot)));
// if deep map, will be keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))));
// if map struct, will be bytes32(uint256(keccak256(abi.encode(key1, keccak256(abi.encode(key0, uint(slot)))))) + structFieldDepth);
function find(StdStorage storage self, bool _clear) internal returns (FindData storage) {
address who = self._target;
bytes4 fsig = self._sig;
uint256 field_depth = self._depth;
bytes memory params = getCallParams(self);
// calldata to test against
if (self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
if (_clear) {
clear(self);
}
return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
}
vm.record();
(, bytes32 callResult) = callTarget(self);
(bytes32[] memory reads,) = vm.accesses(address(who));
if (reads.length == 0) {
revert("stdStorage find(StdStorage): No storage use detected for target.");
} else {
for (uint256 i = reads.length; i > 0;) {
--i;
bytes32 prev = vm.load(who, reads[i]);
if (prev == bytes32(0)) {
emit WARNING_UninitedSlot(who, uint256(reads[i]));
}
if (!checkSlotMutatesCall(self, reads[i])) {
continue;
}
(uint256 offsetLeft, uint256 offsetRight) = (0, 0);
if (self._enable_packed_slots) {
bool found;
(found, offsetLeft, offsetRight) = findOffsets(self, reads[i]);
if (!found) {
continue;
}
}
// Check that value between found offsets is equal to the current call result
uint256 curVal = (uint256(prev) & getMaskByOffsets(offsetLeft, offsetRight)) >> offsetRight;
if (uint256(callResult) != curVal) {
continue;
}
emit SlotFound(who, fsig, keccak256(abi.encodePacked(params, field_depth)), uint256(reads[i]));
self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))] =
FindData(uint256(reads[i]), offsetLeft, offsetRight, true);
break;
}
}
require(
self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found,
"stdStorage find(StdStorage): Slot(s) not found."
);
if (_clear) {
clear(self);
}
return self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
}
/// @notice Sets the target contract address for the storage lookup.
function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
self._target = _target;
return self;
}
/// @notice Sets the target function selector for the storage lookup.
function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
self._sig = _sig;
return self;
}
/// @notice Sets the target function selector from a signature string for the storage lookup.
function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
self._sig = sigs(_sig);
return self;
}
/// @notice Sets raw calldata to use instead of ABI-encoded keys for the target call.
function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
self._calldata = _calldata;
return self;
}
/// @notice Adds an address mapping key to the storage lookup path.
function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
self._keys.push(bytes32(uint256(uint160(who))));
return self;
}
/// @notice Adds a uint256 mapping key to the storage lookup path.
function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
self._keys.push(bytes32(amt));
return self;
}
/// @notice Adds a bytes32 mapping key to the storage lookup path.
function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
self._keys.push(key);
return self;
}
/// @notice Enables detection and handling of values packed into shared storage slots.
function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
self._enable_packed_slots = true;
return self;
}
/// @notice Sets the struct field depth for storage lookups into nested structs.
function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
self._depth = _depth;
return self;
}
function _read(StdStorage storage self) private returns (bytes memory) {
FindData storage data = find(self, false);
uint256 mask = getMaskByOffsets(data.offsetLeft, data.offsetRight);
uint256 value = (uint256(vm.load(self._target, bytes32(data.slot))) & mask) >> data.offsetRight;
clear(self);
return abi.encode(value);
}
/// @notice Reads the found storage slot value as bytes32.
function read_bytes32(StdStorage storage self) internal returns (bytes32) {
return abi.decode(_read(self), (bytes32));
}
/// @notice Reads the found storage slot value as bool.
/// @dev Reverts if the stored value is neither `0` nor `1`.
function read_bool(StdStorage storage self) internal returns (bool) {
int256 v = read_int(self);
if (v == 0) return false;
if (v == 1) return true;
revert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
}
/// @notice Reads the found storage slot value as address.
function read_address(StdStorage storage self) internal returns (address) {
return abi.decode(_read(self), (address));
}
/// @notice Reads the found storage slot value as uint256.
function read_uint(StdStorage storage self) internal returns (uint256) {
return abi.decode(_read(self), (uint256));
}
/// @notice Reads the found storage slot value as int256.
function read_int(StdStorage storage self) internal returns (int256) {
return abi.decode(_read(self), (int256));
}
/// @notice Returns the parent mapping slot index and the key used to reach the found slot.
function parent(StdStorage storage self) internal returns (uint256, bytes32) {
address who = self._target;
uint256 field_depth = self._depth;
vm.startMappingRecording();
uint256 child = find(self, true).slot - field_depth;
(bool found, bytes32 key, bytes32 parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
if (!found) {
revert(
"stdStorage parent(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
);
}
return (uint256(parent_slot), key);
}
/// @notice Returns the root mapping slot index by traversing the mapping parent chain.
function root(StdStorage storage self) internal returns (uint256) {
address who = self._target;
uint256 field_depth = self._depth;
vm.startMappingRecording();
uint256 child = find(self, true).slot - field_depth;
bool found;
bytes32 root_slot;
bytes32 parent_slot;
(found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(child));
if (!found) {
revert(
"stdStorage root(StdStorage): Cannot find parent. Make sure you give a slot and startMappingRecording() has been called."
);
}
while (found) {
root_slot = parent_slot;
(found,, parent_slot) = vm.getMappingKeyAndParentOf(who, bytes32(root_slot));
}
return uint256(root_slot);
}
function _bytesToBytes32(bytes memory b, uint256 offset) private pure returns (bytes32) {
bytes32 out;
// Cap read length by remaining bytes from `offset`, and at most 32 bytes to avoid out-of-bounds
uint256 max = b.length > offset ? b.length - offset : 0;
if (max > 32) {
max = 32;
}
for (uint256 i = 0; i < max; i++) {
out |= bytes32(b[offset + i] & 0xFF) >> (i * 8);
}
return out;
}
function _flatten(bytes32[] memory b) private pure returns (bytes memory) {
bytes memory result = new bytes(b.length * 32);
for (uint256 i = 0; i < b.length; i++) {
bytes32 k = b[i];
assembly ("memory-safe") {
mstore(add(result, add(32, mul(32, i))), k)
}
}
return result;
}
/// @notice Resets all configured parameters on `self`.
function clear(StdStorage storage self) internal {
delete self._target;
delete self._sig;
delete self._keys;
delete self._depth;
delete self._enable_packed_slots;
delete self._calldata;
}
/// @notice Returns a bitmask with ones in the bit range `[offsetRight, 255 - offsetLeft]`.
/// @dev `(slotValue & mask) >> offsetRight` extracts the packed variable's value.
function getMaskByOffsets(uint256 offsetLeft, uint256 offsetRight) internal pure returns (uint256 mask) {
// mask = ((1 << (256 - (offsetRight + offsetLeft))) - 1) << offsetRight;
// using assembly because (1 << 256) causes overflow
assembly {
mask := shl(offsetRight, sub(shl(sub(256, add(offsetRight, offsetLeft)), 1), 1))
}
}
/// @notice Returns `curValue` with the packed variable at `[offsetRight, 255 - offsetLeft]` replaced by `varValue`.
function getUpdatedSlotValue(bytes32 curValue, uint256 varValue, uint256 offsetLeft, uint256 offsetRight)
internal
pure
returns (bytes32 newValue)
{
return bytes32((uint256(curValue) & ~getMaskByOffsets(offsetLeft, offsetRight)) | (varValue << offsetRight));
}
}
library stdStorage {
Vm private constant vm = Vm(address(uint160(uint256(keccak256("hevm cheat code")))));
/// @notice Returns the 4-byte function selector for `sigStr`.
function sigs(string memory sigStr) internal pure returns (bytes4) {
return stdStorageSafe.sigs(sigStr);
}
/// @notice Finds the storage slot index for the configured target, clearing the configuration.
function find(StdStorage storage self) internal returns (uint256) {
return find(self, true);
}
/// @notice Finds the storage slot index for the configured target, optionally clearing the configuration.
function find(StdStorage storage self, bool _clear) internal returns (uint256) {
return stdStorageSafe.find(self, _clear).slot;
}
/// @notice Sets the target contract address for the storage lookup.
function target(StdStorage storage self, address _target) internal returns (StdStorage storage) {
return stdStorageSafe.target(self, _target);
}
/// @notice Sets the target function selector for the storage lookup.
function sig(StdStorage storage self, bytes4 _sig) internal returns (StdStorage storage) {
return stdStorageSafe.sig(self, _sig);
}
/// @notice Sets the target function selector from a signature string for the storage lookup.
function sig(StdStorage storage self, string memory _sig) internal returns (StdStorage storage) {
return stdStorageSafe.sig(self, _sig);
}
/// @notice Adds an address mapping key to the storage lookup path.
function with_key(StdStorage storage self, address who) internal returns (StdStorage storage) {
return stdStorageSafe.with_key(self, who);
}
/// @notice Adds a uint256 mapping key to the storage lookup path.
function with_key(StdStorage storage self, uint256 amt) internal returns (StdStorage storage) {
return stdStorageSafe.with_key(self, amt);
}
/// @notice Adds a bytes32 mapping key to the storage lookup path.
function with_key(StdStorage storage self, bytes32 key) internal returns (StdStorage storage) {
return stdStorageSafe.with_key(self, key);
}
/// @notice Sets raw calldata to use instead of ABI-encoded keys for the target call.
function with_calldata(StdStorage storage self, bytes memory _calldata) internal returns (StdStorage storage) {
return stdStorageSafe.with_calldata(self, _calldata);
}
/// @notice Enables detection and handling of values packed into shared storage slots.
function enable_packed_slots(StdStorage storage self) internal returns (StdStorage storage) {
return stdStorageSafe.enable_packed_slots(self);
}
/// @notice Sets the struct field depth for storage lookups into nested structs.
function depth(StdStorage storage self, uint256 _depth) internal returns (StdStorage storage) {
return stdStorageSafe.depth(self, _depth);
}
/// @notice Resets all configured parameters on `self`.
function clear(StdStorage storage self) internal {
stdStorageSafe.clear(self);
}
/// @notice Writes `who` to the found storage slot and verifies the value was applied correctly.
function checked_write(StdStorage storage self, address who) internal {
checked_write(self, bytes32(uint256(uint160(who))));
}
/// @notice Writes `amt` to the found storage slot and verifies the value was applied correctly.
function checked_write(StdStorage storage self, uint256 amt) internal {
checked_write(self, bytes32(amt));
}
/// @notice Writes `val` to the found storage slot and verifies the value was applied correctly.
function checked_write_int(StdStorage storage self, int256 val) internal {
checked_write(self, bytes32(uint256(val)));
}
/// @notice Writes `write` to the found storage slot and verifies the value was applied correctly.
function checked_write(StdStorage storage self, bool write) internal {
bytes32 t;
assembly ("memory-safe") {
t := write
}
checked_write(self, t);
}
/// @notice Writes `set` to the found storage slot and verifies the value was applied correctly.
function checked_write(StdStorage storage self, bytes32 set) internal {
address who = self._target;
bytes4 fsig = self._sig;
uint256 field_depth = self._depth;
bytes memory params = stdStorageSafe.getCallParams(self);
if (!self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))].found) {
find(self, false);
}
FindData storage data = self.finds[who][fsig][keccak256(abi.encodePacked(params, field_depth))];
if ((data.offsetLeft + data.offsetRight) > 0) {
uint256 maxVal = 2 ** (256 - (data.offsetLeft + data.offsetRight));
require(
uint256(set) < maxVal,
string(
abi.encodePacked(
"stdStorage checked_write(StdStorage): Packed slot. We can't fit value greater than ",
vm.toString(maxVal)
)
)
);
}
bytes32 curVal = vm.load(who, bytes32(data.slot));
bytes32 valToSet = stdStorageSafe.getUpdatedSlotValue(curVal, uint256(set), data.offsetLeft, data.offsetRight);
vm.store(who, bytes32(data.slot), valToSet);
(bool success, bytes32 callResult) = stdStorageSafe.callTarget(self);
if (!success || callResult != set) {
vm.store(who, bytes32(data.slot), curVal);
revert("stdStorage checked_write(StdStorage): Failed to write value.");
}
clear(self);
}
/// @notice Reads the found storage slot value as bytes32.
function read_bytes32(StdStorage storage self) internal returns (bytes32) {
return stdStorageSafe.read_bytes32(self);
}
/// @notice Reads the found storage slot value as bool.
function read_bool(StdStorage storage self) internal returns (bool) {
return stdStorageSafe.read_bool(self);
}
/// @notice Reads the found storage slot value as address.
function read_address(StdStorage storage self) internal returns (address) {
return stdStorageSafe.read_address(self);
}
/// @notice Reads the found storage slot value as uint256.
function read_uint(StdStorage storage self) internal returns (uint256) {
return stdStorageSafe.read_uint(self);
}
/// @notice Reads the found storage slot value as int256.
function read_int(StdStorage storage self) internal returns (int256) {
return stdStorageSafe.read_int(self);
}
/// @notice Returns the parent mapping slot index and the key used to reach the found slot.
function parent(StdStorage storage self) internal returns (uint256, bytes32) {
return stdStorageSafe.parent(self);
}
/// @notice Returns the root mapping slot index by traversing the mapping parent chain.
function root(StdStorage storage self) internal returns (uint256) {
return stdStorageSafe.root(self);
}
}

410
packages/contracts/lib/forge-std/src/StdStyle.sol Normal file
View file

@ -0,0 +1,410 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {VmSafe} from "./Vm.sol";
library StdStyle {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
string constant RED = "\u001b[91m";
string constant GREEN = "\u001b[92m";
string constant YELLOW = "\u001b[93m";
string constant BLUE = "\u001b[94m";
string constant MAGENTA = "\u001b[95m";
string constant CYAN = "\u001b[96m";
string constant BOLD = "\u001b[1m";
string constant DIM = "\u001b[2m";
string constant ITALIC = "\u001b[3m";
string constant UNDERLINE = "\u001b[4m";
string constant INVERSE = "\u001b[7m";
string constant RESET = "\u001b[0m";
function _styleConcat(string memory style, string memory self) private pure returns (string memory) {
return string(abi.encodePacked(style, self, RESET));
}
/// @notice Returns `self` wrapped in red ANSI color codes.
function red(string memory self) internal pure returns (string memory) {
return _styleConcat(RED, self);
}
/// @notice Returns the string representation of `self` wrapped in red ANSI color codes.
function red(uint256 self) internal pure returns (string memory) {
return red(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in red ANSI color codes.
function red(int256 self) internal pure returns (string memory) {
return red(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in red ANSI color codes.
function red(address self) internal pure returns (string memory) {
return red(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in red ANSI color codes.
function red(bool self) internal pure returns (string memory) {
return red(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in red ANSI color codes.
function redBytes(bytes memory self) internal pure returns (string memory) {
return red(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in red ANSI color codes.
function redBytes32(bytes32 self) internal pure returns (string memory) {
return red(vm.toString(self));
}
/// @notice Returns `self` wrapped in green ANSI color codes.
function green(string memory self) internal pure returns (string memory) {
return _styleConcat(GREEN, self);
}
/// @notice Returns the string representation of `self` wrapped in green ANSI color codes.
function green(uint256 self) internal pure returns (string memory) {
return green(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in green ANSI color codes.
function green(int256 self) internal pure returns (string memory) {
return green(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in green ANSI color codes.
function green(address self) internal pure returns (string memory) {
return green(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in green ANSI color codes.
function green(bool self) internal pure returns (string memory) {
return green(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in green ANSI color codes.
function greenBytes(bytes memory self) internal pure returns (string memory) {
return green(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in green ANSI color codes.
function greenBytes32(bytes32 self) internal pure returns (string memory) {
return green(vm.toString(self));
}
/// @notice Returns `self` wrapped in yellow ANSI color codes.
function yellow(string memory self) internal pure returns (string memory) {
return _styleConcat(YELLOW, self);
}
/// @notice Returns the string representation of `self` wrapped in yellow ANSI color codes.
function yellow(uint256 self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in yellow ANSI color codes.
function yellow(int256 self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in yellow ANSI color codes.
function yellow(address self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in yellow ANSI color codes.
function yellow(bool self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in yellow ANSI color codes.
function yellowBytes(bytes memory self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in yellow ANSI color codes.
function yellowBytes32(bytes32 self) internal pure returns (string memory) {
return yellow(vm.toString(self));
}
/// @notice Returns `self` wrapped in blue ANSI color codes.
function blue(string memory self) internal pure returns (string memory) {
return _styleConcat(BLUE, self);
}
/// @notice Returns the string representation of `self` wrapped in blue ANSI color codes.
function blue(uint256 self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in blue ANSI color codes.
function blue(int256 self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in blue ANSI color codes.
function blue(address self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in blue ANSI color codes.
function blue(bool self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in blue ANSI color codes.
function blueBytes(bytes memory self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in blue ANSI color codes.
function blueBytes32(bytes32 self) internal pure returns (string memory) {
return blue(vm.toString(self));
}
/// @notice Returns `self` wrapped in magenta ANSI color codes.
function magenta(string memory self) internal pure returns (string memory) {
return _styleConcat(MAGENTA, self);
}
/// @notice Returns the string representation of `self` wrapped in magenta ANSI color codes.
function magenta(uint256 self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in magenta ANSI color codes.
function magenta(int256 self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in magenta ANSI color codes.
function magenta(address self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in magenta ANSI color codes.
function magenta(bool self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in magenta ANSI color codes.
function magentaBytes(bytes memory self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in magenta ANSI color codes.
function magentaBytes32(bytes32 self) internal pure returns (string memory) {
return magenta(vm.toString(self));
}
/// @notice Returns `self` wrapped in cyan ANSI color codes.
function cyan(string memory self) internal pure returns (string memory) {
return _styleConcat(CYAN, self);
}
/// @notice Returns the string representation of `self` wrapped in cyan ANSI color codes.
function cyan(uint256 self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in cyan ANSI color codes.
function cyan(int256 self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in cyan ANSI color codes.
function cyan(address self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in cyan ANSI color codes.
function cyan(bool self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in cyan ANSI color codes.
function cyanBytes(bytes memory self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in cyan ANSI color codes.
function cyanBytes32(bytes32 self) internal pure returns (string memory) {
return cyan(vm.toString(self));
}
/// @notice Returns `self` wrapped in bold ANSI style codes.
function bold(string memory self) internal pure returns (string memory) {
return _styleConcat(BOLD, self);
}
/// @notice Returns the string representation of `self` wrapped in bold ANSI style codes.
function bold(uint256 self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in bold ANSI style codes.
function bold(int256 self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in bold ANSI style codes.
function bold(address self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in bold ANSI style codes.
function bold(bool self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in bold ANSI style codes.
function boldBytes(bytes memory self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in bold ANSI style codes.
function boldBytes32(bytes32 self) internal pure returns (string memory) {
return bold(vm.toString(self));
}
/// @notice Returns `self` wrapped in dim ANSI style codes.
function dim(string memory self) internal pure returns (string memory) {
return _styleConcat(DIM, self);
}
/// @notice Returns the string representation of `self` wrapped in dim ANSI style codes.
function dim(uint256 self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in dim ANSI style codes.
function dim(int256 self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in dim ANSI style codes.
function dim(address self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in dim ANSI style codes.
function dim(bool self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in dim ANSI style codes.
function dimBytes(bytes memory self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in dim ANSI style codes.
function dimBytes32(bytes32 self) internal pure returns (string memory) {
return dim(vm.toString(self));
}
/// @notice Returns `self` wrapped in italic ANSI style codes.
function italic(string memory self) internal pure returns (string memory) {
return _styleConcat(ITALIC, self);
}
/// @notice Returns the string representation of `self` wrapped in italic ANSI style codes.
function italic(uint256 self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in italic ANSI style codes.
function italic(int256 self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in italic ANSI style codes.
function italic(address self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in italic ANSI style codes.
function italic(bool self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in italic ANSI style codes.
function italicBytes(bytes memory self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in italic ANSI style codes.
function italicBytes32(bytes32 self) internal pure returns (string memory) {
return italic(vm.toString(self));
}
/// @notice Returns `self` wrapped in underline ANSI style codes.
function underline(string memory self) internal pure returns (string memory) {
return _styleConcat(UNDERLINE, self);
}
/// @notice Returns the string representation of `self` wrapped in underline ANSI style codes.
function underline(uint256 self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in underline ANSI style codes.
function underline(int256 self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in underline ANSI style codes.
function underline(address self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in underline ANSI style codes.
function underline(bool self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in underline ANSI style codes.
function underlineBytes(bytes memory self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in underline ANSI style codes.
function underlineBytes32(bytes32 self) internal pure returns (string memory) {
return underline(vm.toString(self));
}
/// @notice Returns `self` wrapped in inverse ANSI style codes.
function inverse(string memory self) internal pure returns (string memory) {
return _styleConcat(INVERSE, self);
}
/// @notice Returns the string representation of `self` wrapped in inverse ANSI style codes.
function inverse(uint256 self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in inverse ANSI style codes.
function inverse(int256 self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in inverse ANSI style codes.
function inverse(address self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in inverse ANSI style codes.
function inverse(bool self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in inverse ANSI style codes.
function inverseBytes(bytes memory self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
/// @notice Returns the string representation of `self` wrapped in inverse ANSI style codes.
function inverseBytes32(bytes32 self) internal pure returns (string memory) {
return inverse(vm.toString(self));
}
}

323
packages/contracts/lib/forge-std/src/StdToml.sol Normal file
View file

@ -0,0 +1,323 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {VmSafe} from "./Vm.sol";
// Helpers for parsing and writing TOML files
// To parse:
// ```
// using stdToml for string;
// string memory toml = vm.readFile("<some_path>");
// toml.readUint("<toml_path>");
// ```
// To write:
// ```
// using stdToml for string;
// string memory toml = "toml";
// toml.serialize("a", uint256(123));
// string memory semiFinal = toml.serialize("b", string("test"));
// string memory finalToml = toml.serialize("c", semiFinal);
// finalToml.write("<some_path>");
// ```
library stdToml {
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
/// @notice Returns whether `key` exists in `toml`.
function keyExists(string memory toml, string memory key) internal view returns (bool) {
return vm.keyExistsToml(toml, key);
}
/// @notice ABI-encodes the TOML value selected by `key`.
function parseRaw(string memory toml, string memory key) internal pure returns (bytes memory) {
return vm.parseToml(toml, key);
}
/// @notice Reads a uint256 value at `key` from `toml`.
function readUint(string memory toml, string memory key) internal pure returns (uint256) {
return vm.parseTomlUint(toml, key);
}
/// @notice Reads a uint256 array at `key` from `toml`.
function readUintArray(string memory toml, string memory key) internal pure returns (uint256[] memory) {
return vm.parseTomlUintArray(toml, key);
}
/// @notice Reads an int256 value at `key` from `toml`.
function readInt(string memory toml, string memory key) internal pure returns (int256) {
return vm.parseTomlInt(toml, key);
}
/// @notice Reads an int256 array at `key` from `toml`.
function readIntArray(string memory toml, string memory key) internal pure returns (int256[] memory) {
return vm.parseTomlIntArray(toml, key);
}
/// @notice Reads a bytes32 value at `key` from `toml`.
function readBytes32(string memory toml, string memory key) internal pure returns (bytes32) {
return vm.parseTomlBytes32(toml, key);
}
/// @notice Reads a bytes32 array at `key` from `toml`.
function readBytes32Array(string memory toml, string memory key) internal pure returns (bytes32[] memory) {
return vm.parseTomlBytes32Array(toml, key);
}
/// @notice Reads a string value at `key` from `toml`.
function readString(string memory toml, string memory key) internal pure returns (string memory) {
return vm.parseTomlString(toml, key);
}
/// @notice Reads a string array at `key` from `toml`.
function readStringArray(string memory toml, string memory key) internal pure returns (string[] memory) {
return vm.parseTomlStringArray(toml, key);
}
/// @notice Reads an address value at `key` from `toml`.
function readAddress(string memory toml, string memory key) internal pure returns (address) {
return vm.parseTomlAddress(toml, key);
}
/// @notice Reads an address array at `key` from `toml`.
function readAddressArray(string memory toml, string memory key) internal pure returns (address[] memory) {
return vm.parseTomlAddressArray(toml, key);
}
/// @notice Reads a bool value at `key` from `toml`.
function readBool(string memory toml, string memory key) internal pure returns (bool) {
return vm.parseTomlBool(toml, key);
}
/// @notice Reads a bool array at `key` from `toml`.
function readBoolArray(string memory toml, string memory key) internal pure returns (bool[] memory) {
return vm.parseTomlBoolArray(toml, key);
}
/// @notice Reads a bytes value at `key` from `toml`.
function readBytes(string memory toml, string memory key) internal pure returns (bytes memory) {
return vm.parseTomlBytes(toml, key);
}
/// @notice Reads a bytes array at `key` from `toml`.
function readBytesArray(string memory toml, string memory key) internal pure returns (bytes[] memory) {
return vm.parseTomlBytesArray(toml, key);
}
/// @notice Reads a uint256 value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readUintOr(string memory toml, string memory key, uint256 defaultValue) internal view returns (uint256) {
return keyExists(toml, key) ? readUint(toml, key) : defaultValue;
}
/// @notice Reads a uint256 array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readUintArrayOr(string memory toml, string memory key, uint256[] memory defaultValue)
internal
view
returns (uint256[] memory)
{
return keyExists(toml, key) ? readUintArray(toml, key) : defaultValue;
}
/// @notice Reads an int256 value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readIntOr(string memory toml, string memory key, int256 defaultValue) internal view returns (int256) {
return keyExists(toml, key) ? readInt(toml, key) : defaultValue;
}
/// @notice Reads an int256 array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readIntArrayOr(string memory toml, string memory key, int256[] memory defaultValue)
internal
view
returns (int256[] memory)
{
return keyExists(toml, key) ? readIntArray(toml, key) : defaultValue;
}
/// @notice Reads a bytes32 value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readBytes32Or(string memory toml, string memory key, bytes32 defaultValue)
internal
view
returns (bytes32)
{
return keyExists(toml, key) ? readBytes32(toml, key) : defaultValue;
}
/// @notice Reads a bytes32 array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readBytes32ArrayOr(string memory toml, string memory key, bytes32[] memory defaultValue)
internal
view
returns (bytes32[] memory)
{
return keyExists(toml, key) ? readBytes32Array(toml, key) : defaultValue;
}
/// @notice Reads a string value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readStringOr(string memory toml, string memory key, string memory defaultValue)
internal
view
returns (string memory)
{
return keyExists(toml, key) ? readString(toml, key) : defaultValue;
}
/// @notice Reads a string array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readStringArrayOr(string memory toml, string memory key, string[] memory defaultValue)
internal
view
returns (string[] memory)
{
return keyExists(toml, key) ? readStringArray(toml, key) : defaultValue;
}
/// @notice Reads an address value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readAddressOr(string memory toml, string memory key, address defaultValue)
internal
view
returns (address)
{
return keyExists(toml, key) ? readAddress(toml, key) : defaultValue;
}
/// @notice Reads an address array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readAddressArrayOr(string memory toml, string memory key, address[] memory defaultValue)
internal
view
returns (address[] memory)
{
return keyExists(toml, key) ? readAddressArray(toml, key) : defaultValue;
}
/// @notice Reads a bool value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readBoolOr(string memory toml, string memory key, bool defaultValue) internal view returns (bool) {
return keyExists(toml, key) ? readBool(toml, key) : defaultValue;
}
/// @notice Reads a bool array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readBoolArrayOr(string memory toml, string memory key, bool[] memory defaultValue)
internal
view
returns (bool[] memory)
{
return keyExists(toml, key) ? readBoolArray(toml, key) : defaultValue;
}
/// @notice Reads a bytes value at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readBytesOr(string memory toml, string memory key, bytes memory defaultValue)
internal
view
returns (bytes memory)
{
return keyExists(toml, key) ? readBytes(toml, key) : defaultValue;
}
/// @notice Reads a bytes array at `key` from `toml`, returning `defaultValue` if the key does not exist.
function readBytesArrayOr(string memory toml, string memory key, bytes[] memory defaultValue)
internal
view
returns (bytes[] memory)
{
return keyExists(toml, key) ? readBytesArray(toml, key) : defaultValue;
}
/// @notice Serializes a JSON object `rootObject` under `jsonKey` and returns the serialized string.
/// @dev Values are accumulated as JSON in memory; conversion to TOML happens on `write`.
function serialize(string memory jsonKey, string memory rootObject) internal returns (string memory) {
return vm.serializeJson(jsonKey, rootObject);
}
/// @notice Serializes a bool `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, bool value) internal returns (string memory) {
return vm.serializeBool(jsonKey, key, value);
}
/// @notice Serializes a bool array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, bool[] memory value) internal returns (string memory) {
return vm.serializeBool(jsonKey, key, value);
}
/// @notice Serializes a uint256 `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, uint256 value) internal returns (string memory) {
return vm.serializeUint(jsonKey, key, value);
}
/// @notice Serializes a uint256 array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, uint256[] memory value)
internal
returns (string memory)
{
return vm.serializeUint(jsonKey, key, value);
}
/// @notice Serializes an int256 `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, int256 value) internal returns (string memory) {
return vm.serializeInt(jsonKey, key, value);
}
/// @notice Serializes an int256 array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, int256[] memory value)
internal
returns (string memory)
{
return vm.serializeInt(jsonKey, key, value);
}
/// @notice Serializes an address `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, address value) internal returns (string memory) {
return vm.serializeAddress(jsonKey, key, value);
}
/// @notice Serializes an address array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, address[] memory value)
internal
returns (string memory)
{
return vm.serializeAddress(jsonKey, key, value);
}
/// @notice Serializes a bytes32 `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, bytes32 value) internal returns (string memory) {
return vm.serializeBytes32(jsonKey, key, value);
}
/// @notice Serializes a bytes32 array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, bytes32[] memory value)
internal
returns (string memory)
{
return vm.serializeBytes32(jsonKey, key, value);
}
/// @notice Serializes a bytes `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, bytes memory value) internal returns (string memory) {
return vm.serializeBytes(jsonKey, key, value);
}
/// @notice Serializes a bytes array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, bytes[] memory value)
internal
returns (string memory)
{
return vm.serializeBytes(jsonKey, key, value);
}
/// @notice Serializes a string `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, string memory value) internal returns (string memory) {
return vm.serializeString(jsonKey, key, value);
}
/// @notice Serializes a string array `value` under `key` within `jsonKey` and returns the serialized string.
function serialize(string memory jsonKey, string memory key, string[] memory value)
internal
returns (string memory)
{
return vm.serializeString(jsonKey, key, value);
}
/// @notice Writes the serialized object `jsonKey` to `path` as a TOML file.
function write(string memory jsonKey, string memory path) internal {
vm.writeToml(jsonKey, path);
}
/// @notice Writes the value at `valueKey` from the serialized object `jsonKey` to `path` as a TOML file.
function write(string memory jsonKey, string memory path, string memory valueKey) internal {
vm.writeToml(jsonKey, path, valueKey);
}
}

247
packages/contracts/lib/forge-std/src/StdUtils.sol Normal file
View file

@ -0,0 +1,247 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IMulticall3} from "./interfaces/IMulticall3.sol";
import {StdConstants} from "./StdConstants.sol";
import {VmSafe} from "./Vm.sol";
abstract contract StdUtils {
/*//////////////////////////////////////////////////////////////////////////
CONSTANTS
//////////////////////////////////////////////////////////////////////////*/
VmSafe private constant vm = VmSafe(address(uint160(uint256(keccak256("hevm cheat code")))));
address private constant _CONSOLE2_ADDRESS = 0x000000000000000000636F6e736F6c652e6c6f67;
uint256 private constant _INT256_MIN_ABS =
57896044618658097711785492504343953926634992332820282019728792003956564819968;
uint256 private constant _SECP256K1_ORDER =
115792089237316195423570985008687907852837564279074904382605163141518161494337;
uint256 private constant _UINT256_MAX =
115792089237316195423570985008687907853269984665640564039457584007913129639935;
/*//////////////////////////////////////////////////////////////////////////
INTERNAL FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
/// @notice Maps an unsigned integer into the inclusive range `[min, max]`.
/// @dev Values outside the range are wrapped into it.
/// @param x The unsigned value to bound.
/// @param min The inclusive lower bound.
/// @param max The inclusive upper bound.
/// @return result The bounded value.
function _bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
require(min <= max, "StdUtils bound(uint256,uint256,uint256): Max is less than min.");
// If x is between min and max, return x directly. This is to ensure that dictionary values
// do not get shifted if the min is nonzero. More info: https://github.com/foundry-rs/forge-std/issues/188
if (x >= min && x <= max) return x;
uint256 size = max - min + 1;
// If the value is 0, 1, 2, 3, wrap that to min, min+1, min+2, min+3. Similarly for the _UINT256_MAX side.
// This helps ensure coverage of the min/max values.
if (x <= 3 && size > x) return min + x;
if (x >= _UINT256_MAX - 3 && size > _UINT256_MAX - x) return max - (_UINT256_MAX - x);
// Otherwise, wrap x into the range [min, max], i.e. the range is inclusive.
if (x > max) {
uint256 diff = x - max;
uint256 rem = diff % size;
if (rem == 0) return max;
result = min + rem - 1;
} else if (x < min) {
uint256 diff = min - x;
uint256 rem = diff % size;
if (rem == 0) return min;
result = max - rem + 1;
}
}
/// @notice Wrapper for `_bound(uint256,uint256,uint256)`.
/// @param x The unsigned value to bound.
/// @param min The inclusive lower bound.
/// @param max The inclusive upper bound.
/// @return result The bounded value.
function bound(uint256 x, uint256 min, uint256 max) internal pure virtual returns (uint256 result) {
result = _bound(x, min, max);
}
/// @notice Maps a signed integer into the inclusive range `[min, max]`.
/// @dev Values outside the range are wrapped into it.
/// @param x The signed value to bound.
/// @param min The inclusive lower bound.
/// @param max The inclusive upper bound.
/// @return result The bounded value.
function _bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
require(min <= max, "StdUtils bound(int256,int256,int256): Max is less than min.");
// Shifting all int256 values to uint256 to use _bound function. The range of two types are:
// int256 : -(2**255) ~ (2**255 - 1)
// uint256: 0 ~ (2**256 - 1)
// So, add 2**255, _INT256_MIN_ABS to the integer values.
//
// If the given integer value is -2**255, we cannot use `-uint256(-x)` because of the overflow.
// So, use `~uint256(x) + 1` instead.
uint256 _x = x < 0 ? (_INT256_MIN_ABS - ~uint256(x) - 1) : (uint256(x) + _INT256_MIN_ABS);
uint256 _min = min < 0 ? (_INT256_MIN_ABS - ~uint256(min) - 1) : (uint256(min) + _INT256_MIN_ABS);
uint256 _max = max < 0 ? (_INT256_MIN_ABS - ~uint256(max) - 1) : (uint256(max) + _INT256_MIN_ABS);
uint256 y = _bound(_x, _min, _max);
// To move it back to int256 value, subtract _INT256_MIN_ABS at here.
result = y < _INT256_MIN_ABS ? int256(~(_INT256_MIN_ABS - y) + 1) : int256(y - _INT256_MIN_ABS);
}
/// @notice Wrapper for `_bound(int256,int256,int256)`.
/// @param x The signed value to bound.
/// @param min The inclusive lower bound.
/// @param max The inclusive upper bound.
/// @return result The bounded value.
function bound(int256 x, int256 min, int256 max) internal pure virtual returns (int256 result) {
result = _bound(x, min, max);
}
/// @notice Maps a value into the valid secp256k1 private key range `[1, n - 1]`.
/// @param privateKey The raw private key candidate.
/// @return result The bounded private key.
function boundPrivateKey(uint256 privateKey) internal pure virtual returns (uint256 result) {
result = _bound(privateKey, 1, _SECP256K1_ORDER - 1);
}
/// @notice Converts a byte array (up to 32 bytes) into a `uint256`.
/// @param b The byte array to decode.
/// @return The decoded unsigned integer.
function bytesToUint(bytes memory b) internal pure virtual returns (uint256) {
require(b.length <= 32, "StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
return abi.decode(abi.encodePacked(new bytes(32 - b.length), b), (uint256));
}
/// @notice Computes the CREATE deployment address for `deployer` and `nonce`.
/// @dev Deprecated in favor of `vm.computeCreateAddress`.
/// @param deployer The deployer address.
/// @param nonce The deployer nonce used for CREATE.
/// @return The computed CREATE address.
function computeCreateAddress(address deployer, uint256 nonce) internal pure virtual returns (address) {
_console2_log_StdUtils("computeCreateAddress is deprecated. Please use vm.computeCreateAddress instead.");
return vm.computeCreateAddress(deployer, nonce);
}
/// @notice Computes the CREATE2 address from a salt, init code hash, and deployer.
/// @dev Deprecated in favor of `vm.computeCreate2Address`.
/// @param salt The CREATE2 salt.
/// @param initcodeHash The hash of the full init code.
/// @param deployer The deployer address.
/// @return The computed CREATE2 address.
function computeCreate2Address(bytes32 salt, bytes32 initcodeHash, address deployer)
internal
pure
virtual
returns (address)
{
_console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
return vm.computeCreate2Address(salt, initcodeHash, deployer);
}
/// @notice Computes a CREATE2 address using the default CREATE2 deployer.
/// @dev Deprecated in favor of `vm.computeCreate2Address`.
/// @param salt The CREATE2 salt.
/// @param initCodeHash The hash of the full init code.
/// @return The computed CREATE2 address.
function computeCreate2Address(bytes32 salt, bytes32 initCodeHash) internal pure returns (address) {
_console2_log_StdUtils("computeCreate2Address is deprecated. Please use vm.computeCreate2Address instead.");
return vm.computeCreate2Address(salt, initCodeHash);
}
/// @notice Returns the init code hash for CREATE2 without constructor arguments.
/// @param creationCode The creation code of contract `C`, as returned by `type(C).creationCode`.
/// @return The keccak256 hash of the init code.
function hashInitCode(bytes memory creationCode) internal pure returns (bytes32) {
return hashInitCode(creationCode, "");
}
/// @notice Returns the init code hash for CREATE2 with ABI-encoded constructor arguments.
/// @param creationCode The creation code of contract `C`, as returned by `type(C).creationCode`.
/// @param args The ABI-encoded constructor arguments for `C`.
/// @return The keccak256 hash of `creationCode || args`.
function hashInitCode(bytes memory creationCode, bytes memory args) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(creationCode, args));
}
/// @notice Queries ERC-20 balances for multiple addresses in one Multicall3 request.
/// @param token The ERC-20 token contract to query.
/// @param addresses The addresses to query balances for.
/// @return balances The token balances in the same order as `addresses`.
function getTokenBalances(address token, address[] memory addresses)
internal
virtual
returns (uint256[] memory balances)
{
uint256 tokenCodeSize;
assembly {
tokenCodeSize := extcodesize(token)
}
require(tokenCodeSize > 0, "StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
// ABI encode the aggregate call to Multicall3.
uint256 length = addresses.length;
IMulticall3.Call[] memory calls = new IMulticall3.Call[](length);
for (uint256 i = 0; i < length; ++i) {
// 0x70a08231 = bytes4(keccak256("balanceOf(address)"))
calls[i] = IMulticall3.Call({target: token, callData: abi.encodeWithSelector(0x70a08231, (addresses[i]))});
}
// Make the aggregate call.
(, bytes[] memory returnData) = StdConstants.MULTICALL3_ADDRESS.aggregate(calls);
// ABI decode the return data and return the balances.
balances = new uint256[](length);
for (uint256 i = 0; i < length; ++i) {
balances[i] = abi.decode(returnData[i], (uint256));
}
}
/*//////////////////////////////////////////////////////////////////////////
PRIVATE FUNCTIONS
//////////////////////////////////////////////////////////////////////////*/
function _addressFromLast20Bytes(bytes32 bytesValue) private pure returns (address) {
return address(uint160(uint256(bytesValue)));
}
// This section is used to prevent the compilation of console, which shortens the compilation time when console is
// not used elsewhere. We also trick the compiler into letting us make the console log methods as `pure` to avoid
// any breaking changes to function signatures.
function _castLogPayloadViewToPure(function(bytes memory) internal view fnIn)
internal
pure
returns (function(bytes memory) internal pure fnOut)
{
assembly {
fnOut := fnIn
}
}
function _sendLogPayload(bytes memory payload) internal pure {
_castLogPayloadViewToPure(_sendLogPayloadView)(payload);
}
function _sendLogPayloadView(bytes memory payload) private view {
uint256 payloadLength = payload.length;
address consoleAddress = _CONSOLE2_ADDRESS;
assembly ("memory-safe") {
let payloadStart := add(payload, 32)
let r := staticcall(gas(), consoleAddress, payloadStart, payloadLength, 0, 0)
}
}
function _console2_log_StdUtils(string memory p0) private pure {
_sendLogPayload(abi.encodeWithSignature("log(string)", p0));
}
function _console2_log_StdUtils(string memory p0, uint256 p1) private pure {
_sendLogPayload(abi.encodeWithSignature("log(string,uint256)", p0, p1));
}
function _console2_log_StdUtils(string memory p0, string memory p1) private pure {
_sendLogPayload(abi.encodeWithSignature("log(string,string)", p0, p1));
}
}

32
packages/contracts/lib/forge-std/src/Test.sol Normal file
View file

@ -0,0 +1,32 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
// 💬 ABOUT
// Forge Std's default Test.
// 🧩 MODULES
import {console} from "./console.sol";
import {console2} from "./console2.sol";
import {safeconsole} from "./safeconsole.sol";
import {StdAssertions} from "./StdAssertions.sol";
import {StdChains} from "./StdChains.sol";
import {StdCheats} from "./StdCheats.sol";
import {StdConstants} from "./StdConstants.sol";
import {stdError} from "./StdError.sol";
import {StdInvariant} from "./StdInvariant.sol";
import {stdJson} from "./StdJson.sol";
import {stdMath} from "./StdMath.sol";
import {StdStorage, stdStorage} from "./StdStorage.sol";
import {StdStyle} from "./StdStyle.sol";
import {stdToml} from "./StdToml.sol";
import {StdUtils} from "./StdUtils.sol";
import {Vm} from "./Vm.sol";
// 📦 BOILERPLATE
import {TestBase} from "./Base.sol";
// ⭐️ TEST
abstract contract Test is TestBase, StdAssertions, StdChains, StdCheats, StdInvariant, StdUtils {
// Note: IS_TEST() must return true.
bool public IS_TEST = true;
}

2637
packages/contracts/lib/forge-std/src/Vm.sol generated Normal file
View file

File diff suppressed because it is too large Load diff

1599
packages/contracts/lib/forge-std/src/console.sol Normal file
View file

File diff suppressed because it is too large Load diff

4
packages/contracts/lib/forge-std/src/console2.sol Normal file
View file

@ -0,0 +1,4 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {console as console2} from "./console.sol";

105
packages/contracts/lib/forge-std/src/interfaces/IERC1155.sol Normal file
View file

@ -0,0 +1,105 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IERC165} from "./IERC165.sol";
/// @title ERC-1155 Multi Token Standard
/// @dev See https://eips.ethereum.org/EIPS/eip-1155
/// Note: The ERC-165 identifier for this interface is 0xd9b67a26.
interface IERC1155 is IERC165 {
/// @dev
/// - Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
/// - The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
/// - The `_from` argument MUST be the address of the holder whose balance is decreased.
/// - The `_to` argument MUST be the address of the recipient whose balance is increased.
/// - The `_id` argument MUST be the token type being transferred.
/// - The `_value` argument MUST be the number of tokens the holder balance is decreased by and match what the recipient balance is increased by.
/// - When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
/// - When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
event TransferSingle(
address indexed _operator, address indexed _from, address indexed _to, uint256 _id, uint256 _value
);
/// @dev
/// - Either `TransferSingle` or `TransferBatch` MUST emit when tokens are transferred, including zero value transfers as well as minting or burning (see "Safe Transfer Rules" section of the standard).
/// - The `_operator` argument MUST be the address of an account/contract that is approved to make the transfer (SHOULD be msg.sender).
/// - The `_from` argument MUST be the address of the holder whose balance is decreased.
/// - The `_to` argument MUST be the address of the recipient whose balance is increased.
/// - The `_ids` argument MUST be the list of tokens being transferred.
/// - The `_values` argument MUST be the list of number of tokens (matching the list and order of tokens specified in _ids) the holder balance is decreased by and match what the recipient balance is increased by.
/// - When minting/creating tokens, the `_from` argument MUST be set to `0x0` (i.e. zero address).
/// - When burning/destroying tokens, the `_to` argument MUST be set to `0x0` (i.e. zero address).
event TransferBatch(
address indexed _operator, address indexed _from, address indexed _to, uint256[] _ids, uint256[] _values
);
/// @dev MUST emit when approval for a second party/operator address to manage all tokens for an owner address is enabled or disabled (absence of an event assumes disabled).
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
/// @dev MUST emit when the URI is updated for a token ID. URIs are defined in RFC 3986.
/// The URI MUST point to a JSON file that conforms to the "ERC-1155 Metadata URI JSON Schema".
event URI(string _value, uint256 indexed _id);
/// @notice Transfers `_value` amount of an `_id` from the `_from` address to the `_to` address specified (with safety call).
/// @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
/// - MUST revert if `_to` is the zero address.
/// - MUST revert if balance of holder for token `_id` is lower than the `_value` sent.
/// - MUST revert on any other error.
/// - MUST emit the `TransferSingle` event to reflect the balance change (see "Safe Transfer Rules" section of the standard).
/// - After the above conditions are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call `onERC1155Received` on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
/// @param _from Source address
/// @param _to Target address
/// @param _id ID of the token type
/// @param _value Transfer amount
/// @param _data Additional data with no specified format, MUST be sent unaltered in call to `onERC1155Received` on `_to`
function safeTransferFrom(address _from, address _to, uint256 _id, uint256 _value, bytes calldata _data) external;
/// @notice Transfers `_values` amount(s) of `_ids` from the `_from` address to the `_to` address specified (with safety call).
/// @dev Caller must be approved to manage the tokens being transferred out of the `_from` account (see "Approval" section of the standard).
/// - MUST revert if `_to` is the zero address.
/// - MUST revert if length of `_ids` is not the same as length of `_values`.
/// - MUST revert if any of the balance(s) of the holder(s) for token(s) in `_ids` is lower than the respective amount(s) in `_values` sent to the recipient.
/// - MUST revert on any other error.
/// - MUST emit `TransferSingle` or `TransferBatch` event(s) such that all the balance changes are reflected (see "Safe Transfer Rules" section of the standard).
/// - Balance changes and events MUST follow the ordering of the arrays (_ids[0]/_values[0] before _ids[1]/_values[1], etc).
/// - After the above conditions for the transfer(s) in the batch are met, this function MUST check if `_to` is a smart contract (e.g. code size > 0). If so, it MUST call the relevant `ERC1155TokenReceiver` hook(s) on `_to` and act appropriately (see "Safe Transfer Rules" section of the standard).
/// @param _from Source address
/// @param _to Target address
/// @param _ids IDs of each token type (order and length must match _values array)
/// @param _values Transfer amounts per token type (order and length must match _ids array)
/// @param _data Additional data with no specified format, MUST be sent unaltered in call to the `ERC1155TokenReceiver` hook(s) on `_to`
function safeBatchTransferFrom(
address _from,
address _to,
uint256[] calldata _ids,
uint256[] calldata _values,
bytes calldata _data
) external;
/// @notice Get the balance of an account's tokens.
/// @param _owner The address of the token holder
/// @param _id ID of the token
/// @return The _owner's balance of the token type requested
function balanceOf(address _owner, uint256 _id) external view returns (uint256);
/// @notice Get the balance of multiple account/token pairs
/// @param _owners The addresses of the token holders
/// @param _ids ID of the tokens
/// @return The _owner's balance of the token types requested (i.e. balance for each (owner, id) pair)
function balanceOfBatch(address[] calldata _owners, uint256[] calldata _ids)
external
view
returns (uint256[] memory);
/// @notice Enable or disable approval for a third party ("operator") to manage all of the caller's tokens.
/// @dev MUST emit the ApprovalForAll event on success.
/// @param _operator Address to add to the set of authorized operators
/// @param _approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address _operator, bool _approved) external;
/// @notice Queries the approval status of an operator for a given owner.
/// @param _owner The owner of the tokens
/// @param _operator Address of authorized operator
/// @return True if the operator is approved, false if not
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}

12
packages/contracts/lib/forge-std/src/interfaces/IERC165.sol Normal file
View file

@ -0,0 +1,12 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
interface IERC165 {
/// @notice Query if a contract implements an interface
/// @param interfaceID The interface identifier, as specified in ERC-165
/// @dev Interface identification is specified in ERC-165. This function
/// uses less than 30,000 gas.
/// @return `true` if the contract implements `interfaceID` and
/// `interfaceID` is not 0xffffffff, `false` otherwise
function supportsInterface(bytes4 interfaceID) external view returns (bool);
}

43
packages/contracts/lib/forge-std/src/interfaces/IERC20.sol Normal file
View file

@ -0,0 +1,43 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
/// @dev Interface of the ERC20 standard as defined in the EIP.
/// @dev This includes the optional name, symbol, and decimals metadata.
interface IERC20 {
/// @dev Emitted when `value` tokens are moved from one account (`from`) to another (`to`).
event Transfer(address indexed from, address indexed to, uint256 value);
/// @dev Emitted when the allowance of a `spender` for an `owner` is set, where `value`
/// is the new allowance.
event Approval(address indexed owner, address indexed spender, uint256 value);
/// @notice Returns the amount of tokens in existence.
function totalSupply() external view returns (uint256);
/// @notice Returns the amount of tokens owned by `account`.
function balanceOf(address account) external view returns (uint256);
/// @notice Moves `amount` tokens from the caller's account to `to`.
function transfer(address to, uint256 amount) external returns (bool);
/// @notice Returns the remaining number of tokens that `spender` is allowed
/// to spend on behalf of `owner`
function allowance(address owner, address spender) external view returns (uint256);
/// @notice Sets `amount` as the allowance of `spender` over the caller's tokens.
/// @dev Be aware of front-running risks: https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
function approve(address spender, uint256 amount) external returns (bool);
/// @notice Moves `amount` tokens from `from` to `to` using the allowance mechanism.
/// `amount` is then deducted from the caller's allowance.
function transferFrom(address from, address to, uint256 amount) external returns (bool);
/// @notice Returns the name of the token.
function name() external view returns (string memory);
/// @notice Returns the symbol of the token.
function symbol() external view returns (string memory);
/// @notice Returns the decimals places of the token.
function decimals() external view returns (uint8);
}

190
packages/contracts/lib/forge-std/src/interfaces/IERC4626.sol Normal file
View file

@ -0,0 +1,190 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IERC20} from "./IERC20.sol";
/// @dev Interface of the ERC4626 "Tokenized Vault Standard", as defined in
/// https://eips.ethereum.org/EIPS/eip-4626
interface IERC4626 is IERC20 {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
);
/// @notice Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
/// @dev
/// - MUST be an ERC-20 token contract.
/// - MUST NOT revert.
function asset() external view returns (address assetTokenAddress);
/// @notice Returns the total amount of the underlying asset that is “managed” by Vault.
/// @dev
/// - SHOULD include any compounding that occurs from yield.
/// - MUST be inclusive of any fees that are charged against assets in the Vault.
/// - MUST NOT revert.
function totalAssets() external view returns (uint256 totalManagedAssets);
/// @notice Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
/// scenario where all the conditions are met.
/// @dev
/// - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
/// - MUST NOT show any variations depending on the caller.
/// - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
/// - MUST NOT revert.
///
/// NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
/// “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
/// from.
function convertToShares(uint256 assets) external view returns (uint256 shares);
/// @notice Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
/// scenario where all the conditions are met.
/// @dev
/// - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
/// - MUST NOT show any variations depending on the caller.
/// - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
/// - MUST NOT revert.
///
/// NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
/// “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
/// from.
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/// @notice Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
/// through a deposit call.
/// @dev
/// - MUST return a limited value if receiver is subject to some deposit limit.
/// - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
/// - MUST NOT revert.
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/// @notice Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
/// current on-chain conditions.
/// @dev
/// - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
/// call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
/// in the same transaction.
/// - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
/// deposit would be accepted, regardless if the user has enough tokens approved, etc.
/// - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
/// - MUST NOT revert.
///
/// NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
/// share price or some other type of condition, meaning the depositor will lose assets by depositing.
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/// @notice Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
/// @dev
/// - MUST emit the Deposit event.
/// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
/// deposit execution, and are accounted for during deposit.
/// - MUST revert if all assets cannot be deposited (due to deposit limit being reached, slippage, the user not
/// approving enough underlying tokens to the Vault contract, etc).
///
/// NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/// @notice Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
/// @dev
/// - MUST return a limited value if receiver is subject to some mint limit.
/// - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
/// - MUST NOT revert.
function maxMint(address receiver) external view returns (uint256 maxShares);
/// @notice Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
/// current on-chain conditions.
/// @dev
/// - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
/// in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
/// same transaction.
/// - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
/// would be accepted, regardless if the user has enough tokens approved, etc.
/// - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
/// - MUST NOT revert.
///
/// NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
/// share price or some other type of condition, meaning the depositor will lose assets by minting.
function previewMint(uint256 shares) external view returns (uint256 assets);
/// @notice Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
/// @dev
/// - MUST emit the Deposit event.
/// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
/// execution, and are accounted for during mint.
/// - MUST revert if all shares cannot be minted (due to deposit limit being reached, slippage, the user not
/// approving enough underlying tokens to the Vault contract, etc).
///
/// NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/// @notice Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
/// Vault, through a withdrawal call.
/// @dev
/// - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
/// - MUST NOT revert.
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/// @notice Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
/// given current on-chain conditions.
/// @dev
/// - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
/// call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
/// called
/// in the same transaction.
/// - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
/// the withdrawal would be accepted, regardless if the user has enough shares, etc.
/// - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
/// - MUST NOT revert.
///
/// NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
/// share price or some other type of condition, meaning the owner will lose assets by withdrawing.
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/// @notice Burns shares from owner and sends exactly assets of underlying tokens to receiver.
/// @dev
/// - MUST emit the Withdraw event.
/// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
/// withdraw execution, and are accounted for during withdrawal.
/// - MUST revert if all assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
/// not having enough shares, etc).
///
/// Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
/// Those methods should be performed separately.
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
/// @notice Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
/// through a redeem call.
/// @dev
/// - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
/// - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
/// - MUST NOT revert.
function maxRedeem(address owner) external view returns (uint256 maxShares);
/// @notice Allows an on-chain or off-chain user to simulate the effects of their redemption at the current block,
/// given current on-chain conditions.
/// @dev
/// - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
/// in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
/// same transaction.
/// - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
/// redemption would be accepted, regardless if the user has enough shares, etc.
/// - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
/// - MUST NOT revert.
///
/// NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
/// share price or some other type of condition, meaning the owner will lose assets by redeeming.
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/// @notice Burns exactly shares from owner and sends assets of underlying tokens to receiver.
/// @dev
/// - MUST emit the Withdraw event.
/// - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
/// redeem execution, and are accounted for during redeem.
/// - MUST revert if all shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
/// not having enough shares, etc).
///
/// NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
/// Those methods should be performed separately.
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

72
packages/contracts/lib/forge-std/src/interfaces/IERC6909.sol Normal file
View file

@ -0,0 +1,72 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IERC165} from "./IERC165.sol";
/// @dev Required interface of an ERC-6909 compliant contract, as defined in
/// https://eips.ethereum.org/EIPS/eip-6909
interface IERC6909 is IERC165 {
/// @dev Emitted when the allowance of a `spender` for an `owner` is set for a token of type `id`.
event Approval(address indexed owner, address indexed spender, uint256 indexed id, uint256 amount);
/// @dev Emitted when `owner` grants or revokes operator status for a `spender`.
event OperatorSet(address indexed owner, address indexed spender, bool approved);
/// @dev Emitted when `amount` tokens of type `id` are moved from `sender` to `receiver` initiated by `caller`.
event Transfer(
address caller, address indexed sender, address indexed receiver, uint256 indexed id, uint256 amount
);
///@dev Returns the amount of tokens of type `id` owned by `owner`.
function balanceOf(address owner, uint256 id) external view returns (uint256);
/// @dev Returns the amount of tokens of type `id` that `spender` is allowed to spend on behalf of `owner`.
/// NOTE: Does not include operator allowances.
function allowance(address owner, address spender, uint256 id) external view returns (uint256);
/// @dev Returns true if `spender` is set as an operator for `owner`.
function isOperator(address owner, address spender) external view returns (bool);
/// @dev Sets an approval to `spender` for `amount` tokens of type `id` from the caller's tokens.
/// Must return true.
function approve(address spender, uint256 id, uint256 amount) external returns (bool);
/// @dev Grants or revokes unlimited transfer permission of any token id to `spender` for the caller's tokens.
/// Must return true.
function setOperator(address spender, bool approved) external returns (bool);
/// @dev Transfers `amount` of token type `id` from the caller's account to `receiver`.
/// Must return true.
function transfer(address receiver, uint256 id, uint256 amount) external returns (bool);
/// @dev Transfers `amount` of token type `id` from `sender` to `receiver`.
/// Must return true.
function transferFrom(address sender, address receiver, uint256 id, uint256 amount) external returns (bool);
}
/// @dev Optional extension of {IERC6909} that adds metadata functions.
interface IERC6909Metadata is IERC6909 {
/// @dev Returns the name of the token of type `id`.
function name(uint256 id) external view returns (string memory);
/// @dev Returns the ticker symbol of the token of type `id`.
function symbol(uint256 id) external view returns (string memory);
/// @dev Returns the number of decimals for the token of type `id`.
function decimals(uint256 id) external view returns (uint8);
}
/// @dev Optional extension of {IERC6909} that adds content URI functions.
interface IERC6909ContentURI is IERC6909 {
/// @dev Returns URI for the contract.
function contractURI() external view returns (string memory);
/// @dev Returns the URI for the token of type `id`.
function tokenURI(uint256 id) external view returns (string memory);
}
/// @dev Optional extension of {IERC6909} that adds a token supply function.
interface IERC6909TokenSupply is IERC6909 {
/// @dev Returns the total supply of the token of type `id`.
function totalSupply(uint256 id) external view returns (uint256);
}

164
packages/contracts/lib/forge-std/src/interfaces/IERC721.sol Normal file
View file

@ -0,0 +1,164 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IERC165} from "./IERC165.sol";
/// @title ERC-721 Non-Fungible Token Standard
/// @dev See https://eips.ethereum.org/EIPS/eip-721
/// Note: the ERC-165 identifier for this interface is 0x80ac58cd.
interface IERC721 is IERC165 {
/// @dev This emits when ownership of any NFT changes by any mechanism.
/// This event emits when NFTs are created (`from` == 0) and destroyed
/// (`to` == 0). Exception: during contract creation, any number of NFTs
/// may be created and assigned without emitting Transfer. At the time of
/// any transfer, the approved address for that NFT (if any) is reset to none.
event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);
/// @dev This emits when the approved address for an NFT is changed or
/// reaffirmed. The zero address indicates there is no approved address.
/// When a Transfer event emits, this also indicates that the approved
/// address for that NFT (if any) is reset to none.
event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);
/// @dev This emits when an operator is enabled or disabled for an owner.
/// The operator can manage all NFTs of the owner.
event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);
/// @notice Count all NFTs assigned to an owner
/// @dev NFTs assigned to the zero address are considered invalid, and this
/// function throws for queries about the zero address.
/// @param _owner An address for whom to query the balance
/// @return The number of NFTs owned by `_owner`, possibly zero
function balanceOf(address _owner) external view returns (uint256);
/// @notice Find the owner of an NFT
/// @dev NFTs assigned to zero address are considered invalid, and queries
/// about them do throw.
/// @param _tokenId The identifier for an NFT
/// @return The address of the owner of the NFT
function ownerOf(uint256 _tokenId) external view returns (address);
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `_from` is
/// not the current owner. Throws if `_to` is the zero address. Throws if
/// `_tokenId` is not a valid NFT. When transfer is complete, this function
/// checks if `_to` is a smart contract (code size > 0). If so, it calls
/// `onERC721Received` on `_to` and throws if the return value is not
/// `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
/// @param data Additional data with no specified format, sent in call to `_to`
function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external payable;
/// @notice Transfers the ownership of an NFT from one address to another address
/// @dev This works identically to the other function with an extra data parameter,
/// except this function just sets data to "".
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;
/// @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
/// TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
/// THEY MAY BE PERMANENTLY LOST
/// @dev Throws unless `msg.sender` is the current owner, an authorized
/// operator, or the approved address for this NFT. Throws if `_from` is
/// not the current owner. Throws if `_to` is the zero address. Throws if
/// `_tokenId` is not a valid NFT.
/// @param _from The current owner of the NFT
/// @param _to The new owner
/// @param _tokenId The NFT to transfer
function transferFrom(address _from, address _to, uint256 _tokenId) external payable;
/// @notice Change or reaffirm the approved address for an NFT
/// @dev The zero address indicates there is no approved address.
/// Throws unless `msg.sender` is the current NFT owner, or an authorized
/// operator of the current owner.
/// @param _approved The new approved NFT controller
/// @param _tokenId The NFT to approve
function approve(address _approved, uint256 _tokenId) external payable;
/// @notice Enable or disable approval for a third party ("operator") to manage
/// all of `msg.sender`'s assets
/// @dev Emits the ApprovalForAll event. The contract MUST allow
/// multiple operators per owner.
/// @param _operator Address to add to the set of authorized operators
/// @param _approved True if the operator is approved, false to revoke approval
function setApprovalForAll(address _operator, bool _approved) external;
/// @notice Get the approved address for a single NFT
/// @dev Throws if `_tokenId` is not a valid NFT.
/// @param _tokenId The NFT to find the approved address for
/// @return The approved address for this NFT, or the zero address if there is none
function getApproved(uint256 _tokenId) external view returns (address);
/// @notice Query if an address is an authorized operator for another address
/// @param _owner The address that owns the NFTs
/// @param _operator The address that acts on behalf of the owner
/// @return True if `_operator` is an approved operator for `_owner`, false otherwise
function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}
/// @dev Note: the ERC-165 identifier for this interface is 0x150b7a02.
interface IERC721TokenReceiver {
/// @notice Handle the receipt of an NFT
/// @dev The ERC721 smart contract calls this function on the recipient
/// after a `transfer`. This function MAY throw to revert and reject the
/// transfer. Return of other than the magic value MUST result in the
/// transaction being reverted.
/// Note: the contract address is always the message sender.
/// @param _operator The address which called `safeTransferFrom` function
/// @param _from The address which previously owned the token
/// @param _tokenId The NFT identifier which is being transferred
/// @param _data Additional data with no specified format
/// @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
/// unless throwing
function onERC721Received(address _operator, address _from, uint256 _tokenId, bytes calldata _data)
external
returns (bytes4);
}
/// @title ERC-721 Non-Fungible Token Standard, optional metadata extension
/// @dev See https://eips.ethereum.org/EIPS/eip-721
/// Note: the ERC-165 identifier for this interface is 0x5b5e139f.
interface IERC721Metadata is IERC721 {
/// @notice A descriptive name for a collection of NFTs in this contract
function name() external view returns (string memory _name);
/// @notice An abbreviated name for NFTs in this contract
function symbol() external view returns (string memory _symbol);
/// @notice A distinct Uniform Resource Identifier (URI) for a given asset.
/// @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
/// 3986. The URI may point to a JSON file that conforms to the "ERC721
/// Metadata JSON Schema".
function tokenURI(uint256 _tokenId) external view returns (string memory);
}
/// @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
/// @dev See https://eips.ethereum.org/EIPS/eip-721
/// Note: the ERC-165 identifier for this interface is 0x780e9d63.
interface IERC721Enumerable is IERC721 {
/// @notice Count NFTs tracked by this contract
/// @return A count of valid NFTs tracked by this contract, where each one of
/// them has an assigned and queryable owner not equal to the zero address
function totalSupply() external view returns (uint256);
/// @notice Enumerate valid NFTs
/// @dev Throws if `_index` >= `totalSupply()`.
/// @param _index A counter less than `totalSupply()`
/// @return The token identifier for the `_index`th NFT,
/// (sort order not specified)
function tokenByIndex(uint256 _index) external view returns (uint256);
/// @notice Enumerate NFTs assigned to an owner
/// @dev Throws if `_index` >= `balanceOf(_owner)` or if
/// `_owner` is the zero address, representing invalid NFTs.
/// @param _owner An address where we are interested in NFTs owned by them
/// @param _index A counter less than `balanceOf(_owner)`
/// @return The token identifier for the `_index`th NFT assigned to `_owner`,
/// (sort order not specified)
function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}

145
packages/contracts/lib/forge-std/src/interfaces/IERC7540.sol Normal file
View file

@ -0,0 +1,145 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IERC7575} from "./IERC7575.sol";
/// @dev Interface of the base operator logic of ERC7540, as defined in
/// https://eips.ethereum.org/EIPS/eip-7540
interface IERC7540Operator {
/**
* @dev The event emitted when an operator is set.
*
* @param controller The address of the controller.
* @param operator The address of the operator.
* @param approved The approval status.
*/
event OperatorSet(address indexed controller, address indexed operator, bool approved);
/**
* @dev Sets or removes an operator for the caller.
*
* @param operator The address of the operator.
* @param approved The approval status.
* @return Whether the call was executed successfully or not
*/
function setOperator(address operator, bool approved) external returns (bool);
/**
* @dev Returns `true` if the `operator` is approved as an operator for an `controller`.
*
* @param controller The address of the controller.
* @param operator The address of the operator.
* @return status The approval status
*/
function isOperator(address controller, address operator) external view returns (bool status);
}
/// @dev Interface of the asynchronous deposit Vault interface of ERC7540, as defined in
/// https://eips.ethereum.org/EIPS/eip-7540
interface IERC7540Deposit is IERC7540Operator {
event DepositRequest(
address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 assets
);
/**
* @dev Transfers assets from sender into the Vault and submits a Request for asynchronous deposit.
*
* - MUST support ERC-20 approve / transferFrom on asset as a deposit Request flow.
* - MUST revert if all assets cannot be requested for deposit.
* - owner MUST be msg.sender unless some unspecified explicit approval is given by the caller,
* approval of ERC-20 tokens from owner to sender is NOT enough.
*
* @param assets the amount of deposit assets to transfer from owner
* @param controller the controller of the request who will be able to operate the request
* @param owner the source of the deposit assets
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault's underlying asset token.
*/
function requestDeposit(uint256 assets, address controller, address owner) external returns (uint256 requestId);
/**
* @dev Returns the amount of requested assets in Pending state.
*
* - MUST NOT include any assets in Claimable state for deposit or mint.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
*/
function pendingDepositRequest(uint256 requestId, address controller) external view returns (uint256 pendingAssets);
/**
* @dev Returns the amount of requested assets in Claimable state for the controller to deposit or mint.
*
* - MUST NOT include any assets in Pending state.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
*/
function claimableDepositRequest(uint256 requestId, address controller)
external
view
returns (uint256 claimableAssets);
/**
* @dev Mints shares Vault shares to receiver by claiming the Request of the controller.
*
* - MUST emit the Deposit event.
* - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
*/
function deposit(uint256 assets, address receiver, address controller) external returns (uint256 shares);
/**
* @dev Mints exactly shares Vault shares to receiver by claiming the Request of the controller.
*
* - MUST emit the Deposit event.
* - controller MUST equal msg.sender unless the controller has approved the msg.sender as an operator.
*/
function mint(uint256 shares, address receiver, address controller) external returns (uint256 assets);
}
/// @dev Interface of the asynchronous redeem Vault interface of ERC7540, as defined in
/// https://eips.ethereum.org/EIPS/eip-7540
interface IERC7540Redeem is IERC7540Operator {
event RedeemRequest(
address indexed controller, address indexed owner, uint256 indexed requestId, address sender, uint256 shares
);
/**
* @dev Assumes control of shares from owner and submits a Request for asynchronous redeem.
*
* - MUST support a redeem Request flow where the control of shares is taken from owner directly.
* - Redeem Request approval of shares for a msg.sender not equal to owner MAY come either from ERC-20 approval
* over the shares of owner or if the owner has approved the msg.sender as an operator.
* - MUST revert if all shares cannot be requested for redeem or withdraw.
*
* @param shares the amount of shares to be redeemed to transfer from owner
* @param controller the controller of the request who will be able to operate the request
* @param owner the source of the shares to be redeemed
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault's share token.
*/
function requestRedeem(uint256 shares, address controller, address owner) external returns (uint256 requestId);
/**
* @dev Returns the amount of requested shares in Pending state.
*
* - MUST NOT include any shares in Claimable state for redeem or withdraw.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
*/
function pendingRedeemRequest(uint256 requestId, address controller) external view returns (uint256 pendingShares);
/**
* @dev Returns the amount of requested shares in Claimable state for the controller to redeem or withdraw.
*
* - MUST NOT include any shares in Pending state for redeem or withdraw.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
*/
function claimableRedeemRequest(uint256 requestId, address controller)
external
view
returns (uint256 claimableShares);
}
/// @dev Interface of the fully asynchronous Vault interface of ERC7540, as defined in
/// https://eips.ethereum.org/EIPS/eip-7540
interface IERC7540 is IERC7540Deposit, IERC7540Redeem, IERC7575 {}

241
packages/contracts/lib/forge-std/src/interfaces/IERC7575.sol Normal file
View file

@ -0,0 +1,241 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {IERC165} from "./IERC165.sol";
/// @dev Interface of the ERC7575 "Multi-Asset ERC-4626 Vaults", as defined in
/// https://eips.ethereum.org/EIPS/eip-7575
interface IERC7575 is IERC165 {
event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);
event Withdraw(
address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares
);
/**
* @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function asset() external view returns (address assetTokenAddress);
/**
* @dev Returns the address of the share token
*
* - MUST be an ERC-20 token contract.
* - MUST NOT revert.
*/
function share() external view returns (address shareTokenAddress);
/**
* @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToShares(uint256 assets) external view returns (uint256 shares);
/**
* @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
* scenario where all the conditions are met.
*
* - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT show any variations depending on the caller.
* - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
* - MUST NOT revert.
*
* NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
* “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
* from.
*/
function convertToAssets(uint256 shares) external view returns (uint256 assets);
/**
* @dev Returns the total amount of the underlying asset that is “managed” by Vault.
*
* - SHOULD include any compounding that occurs from yield.
* - MUST be inclusive of any fees that are charged against assets in the Vault.
* - MUST NOT revert.
*/
function totalAssets() external view returns (uint256 totalManagedAssets);
/**
* @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
* through a deposit call.
*
* - MUST return a limited value if receiver is subject to some deposit limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
* - MUST NOT revert.
*/
function maxDeposit(address receiver) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
* call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
* in the same transaction.
* - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
* deposit would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by depositing.
*/
function previewDeposit(uint256 assets) external view returns (uint256 shares);
/**
* @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* deposit execution, and are accounted for during deposit.
* - MUST revert if all assets cannot be deposited (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
* - MUST return a limited value if receiver is subject to some mint limit.
* - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
* - MUST NOT revert.
*/
function maxMint(address receiver) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
* current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
* in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
* same transaction.
* - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
* would be accepted, regardless if the user has enough tokens approved, etc.
* - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
* share price or some other type of condition, meaning the depositor will lose assets by minting.
*/
function previewMint(uint256 shares) external view returns (uint256 assets);
/**
* @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
*
* - MUST emit the Deposit event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
* execution, and are accounted for during mint.
* - MUST revert if all shares cannot be minted (due to deposit limit being reached, slippage, the user not
* approving enough underlying tokens to the Vault contract, etc).
*
* NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
*/
function mint(uint256 shares, address receiver) external returns (uint256 assets);
/**
* @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
* Vault, through a withdraw call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxWithdraw(address owner) external view returns (uint256 maxAssets);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
* call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
* called
* in the same transaction.
* - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
* the withdrawal would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
* share price or some other type of condition, meaning the owner will lose assets by withdrawing.
*/
function previewWithdraw(uint256 assets) external view returns (uint256 shares);
/**
* @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* withdraw execution, and are accounted for during withdraw.
* - MUST revert if all assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);
/**
* @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
* through a redeem call.
*
* - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
* - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
* - MUST NOT revert.
*/
function maxRedeem(address owner) external view returns (uint256 maxShares);
/**
* @dev Allows an on-chain or off-chain user to simulate the effects of their redemption at the current block,
* given current on-chain conditions.
*
* - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
* in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
* same transaction.
* - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
* redemption would be accepted, regardless if the user has enough shares, etc.
* - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
* - MUST NOT revert.
*
* NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
* share price or some other type of condition, meaning the owner will lose assets by redeeming.
*/
function previewRedeem(uint256 shares) external view returns (uint256 assets);
/**
* @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
*
* - MUST emit the Withdraw event.
* - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
* redeem execution, and are accounted for during redeem.
* - MUST revert if all shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
* not having enough shares, etc).
*
* NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
* Those methods should be performed separately.
*/
function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}
/// @dev Interface of the ERC20 share token, as defined in
/// https://eips.ethereum.org/EIPS/eip-7575
interface IERC7575Share is IERC165 {
event VaultUpdate(address indexed asset, address vault);
/**
* @dev Returns the address of the Vault for the given asset.
*
* @param asset the ERC-20 token to deposit with into the Vault
*/
function vault(address asset) external view returns (address);
}

68
packages/contracts/lib/forge-std/src/interfaces/IMulticall3.sol Normal file
View file

@ -0,0 +1,68 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
interface IMulticall3 {
struct Call {
address target;
bytes callData;
}
struct Call3 {
address target;
bool allowFailure;
bytes callData;
}
struct Call3Value {
address target;
bool allowFailure;
uint256 value;
bytes callData;
}
struct Result {
bool success;
bytes returnData;
}
function aggregate(Call[] calldata calls) external payable returns (uint256 blockNumber, bytes[] memory returnData);
function aggregate3(Call3[] calldata calls) external payable returns (Result[] memory returnData);
function aggregate3Value(Call3Value[] calldata calls) external payable returns (Result[] memory returnData);
function blockAndAggregate(Call[] calldata calls)
external
payable
returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
function getBasefee() external view returns (uint256 basefee);
function getBlockHash(uint256 blockNumber) external view returns (bytes32 blockHash);
function getBlockNumber() external view returns (uint256 blockNumber);
function getChainId() external view returns (uint256 chainid);
function getCurrentBlockCoinbase() external view returns (address coinbase);
function getCurrentBlockDifficulty() external view returns (uint256 difficulty);
function getCurrentBlockGasLimit() external view returns (uint256 gaslimit);
function getCurrentBlockTimestamp() external view returns (uint256 timestamp);
function getEthBalance(address addr) external view returns (uint256 balance);
function getLastBlockHash() external view returns (bytes32 blockHash);
function tryAggregate(bool requireSuccess, Call[] calldata calls)
external
payable
returns (Result[] memory returnData);
function tryBlockAndAggregate(bool requireSuccess, Call[] calldata calls)
external
payable
returns (uint256 blockNumber, bytes32 blockHash, Result[] memory returnData);
}

13248
packages/contracts/lib/forge-std/src/safeconsole.sol Normal file
View file

File diff suppressed because it is too large Load diff

44
packages/contracts/lib/forge-std/test/CommonBase.t.sol Normal file
View file

@ -0,0 +1,44 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {CommonBase} from "../src/Base.sol";
import {StdConstants} from "../src/StdConstants.sol";
import {Test} from "../src/Test.sol";
contract CommonBaseTest is Test {
function testVmAddressValue() public pure {
assertEq(VM_ADDRESS, address(StdConstants.VM));
}
function testConsoleValue() public pure {
assertEq(CONSOLE, StdConstants.CONSOLE);
}
function testCreate2FactoryValue() public pure {
assertEq(CREATE2_FACTORY, StdConstants.CREATE2_FACTORY);
}
function testDefaultSenderValue() public pure {
assertEq(DEFAULT_SENDER, StdConstants.DEFAULT_SENDER);
}
function testDefaultTestContractValue() public pure {
assertEq(DEFAULT_TEST_CONTRACT, StdConstants.DEFAULT_TEST_CONTRACT);
}
function testMulticall3AddressValue() public pure {
assertEq(MULTICALL3_ADDRESS, address(StdConstants.MULTICALL3_ADDRESS));
}
function testSecp256k1OrderValue() public pure {
assertEq(SECP256K1_ORDER, StdConstants.SECP256K1_ORDER);
}
function testUint256MaxValue() public pure {
assertEq(UINT256_MAX, type(uint256).max);
}
function testVmValue() public pure {
assertEq(address(vm), address(StdConstants.VM));
}
}

381
packages/contracts/lib/forge-std/test/Config.t.sol Normal file
View file

@ -0,0 +1,381 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.13;
import {Test} from "../src/Test.sol";
import {Config} from "../src/Config.sol";
import {StdConfig} from "../src/StdConfig.sol";
contract ConfigTest is Test, Config {
function setUp() public {
vm.setEnv("MAINNET_RPC", "https://ethereum.reth.rs/rpc");
vm.setEnv("WETH_MAINNET", "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
vm.setEnv("OPTIMISM_RPC", "https://mainnet.optimism.io");
vm.setEnv("WETH_OPTIMISM", "0x4200000000000000000000000000000000000006");
}
function test_loadConfig() public {
// Deploy the config contract with the test fixture.
_loadConfig("./test/fixtures/config.toml", false);
// -- MAINNET --------------------------------------------------------------
// Read and assert RPC URL for Mainnet (chain ID 1)
assertEq(config.getRpcUrl(1), "https://ethereum.reth.rs/rpc");
// Read and assert boolean values
assertTrue(config.get(1, "is_live").toBool());
bool[] memory bool_array = config.get(1, "bool_array").toBoolArray();
assertTrue(bool_array[0]);
assertFalse(bool_array[1]);
// Read and assert address values
assertEq(config.get(1, "weth").toAddress(), 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2);
address[] memory address_array = config.get(1, "deps").toAddressArray();
assertEq(address_array[0], 0x0000000000000000000000000000000000000000);
assertEq(address_array[1], 0x1111111111111111111111111111111111111111);
// Read and assert bytes32 values
assertEq(config.get(1, "word").toBytes32(), bytes32(uint256(1234)));
bytes32[] memory bytes32_array = config.get(1, "word_array").toBytes32Array();
assertEq(bytes32_array[0], bytes32(uint256(5678)));
assertEq(bytes32_array[1], bytes32(uint256(9999)));
// Read and assert uint values
assertEq(config.get(1, "number").toUint256(), 1234);
uint256[] memory uint_array = config.get(1, "number_array").toUint256Array();
assertEq(uint_array[0], 5678);
assertEq(uint_array[1], 9999);
// Read and assert int values
assertEq(config.get(1, "signed_number").toInt256(), -1234);
int256[] memory int_array = config.get(1, "signed_number_array").toInt256Array();
assertEq(int_array[0], -5678);
assertEq(int_array[1], 9999);
// Read and assert bytes values
assertEq(config.get(1, "b").toBytes(), hex"abcd");
bytes[] memory bytes_array = config.get(1, "b_array").toBytesArray();
assertEq(bytes_array[0], hex"dead");
assertEq(bytes_array[1], hex"beef");
// Read and assert string values
assertEq(config.get(1, "str").toString(), "foo");
string[] memory string_array = config.get(1, "str_array").toStringArray();
assertEq(string_array[0], "bar");
assertEq(string_array[1], "baz");
// -- OPTIMISM ------------------------------------------------------------
// Read and assert RPC URL for Optimism (chain ID 10)
assertEq(config.getRpcUrl(10), "https://mainnet.optimism.io");
// Read and assert boolean values
assertFalse(config.get(10, "is_live").toBool());
bool_array = config.get(10, "bool_array").toBoolArray();
assertFalse(bool_array[0]);
assertTrue(bool_array[1]);
// Read and assert address values
assertEq(config.get(10, "weth").toAddress(), 0x4200000000000000000000000000000000000006);
address_array = config.get(10, "deps").toAddressArray();
assertEq(address_array[0], 0x2222222222222222222222222222222222222222);
assertEq(address_array[1], 0x3333333333333333333333333333333333333333);
// Read and assert bytes32 values
assertEq(config.get(10, "word").toBytes32(), bytes32(uint256(9999)));
bytes32_array = config.get(10, "word_array").toBytes32Array();
assertEq(bytes32_array[0], bytes32(uint256(1234)));
assertEq(bytes32_array[1], bytes32(uint256(5678)));
// Read and assert uint values
assertEq(config.get(10, "number").toUint256(), 9999);
uint_array = config.get(10, "number_array").toUint256Array();
assertEq(uint_array[0], 1234);
assertEq(uint_array[1], 5678);
// Read and assert int values
assertEq(config.get(10, "signed_number").toInt256(), 9999);
int_array = config.get(10, "signed_number_array").toInt256Array();
assertEq(int_array[0], -1234);
assertEq(int_array[1], -5678);
// Read and assert bytes values
assertEq(config.get(10, "b").toBytes(), hex"dcba");
bytes_array = config.get(10, "b_array").toBytesArray();
assertEq(bytes_array[0], hex"c0ffee");
assertEq(bytes_array[1], hex"babe");
// Read and assert string values
assertEq(config.get(10, "str").toString(), "alice");
string_array = config.get(10, "str_array").toStringArray();
assertEq(string_array[0], "bob");
assertEq(string_array[1], "charlie");
}
function test_loadConfigAndForks() public {
_loadConfigAndForks("./test/fixtures/config.toml", false);
// assert that the map of chain id and fork ids is created and that the chain ids actually match
assertEq(forkOf[1], 0);
vm.selectFork(forkOf[1]);
assertEq(vm.getChainId(), 1);
assertEq(forkOf[10], 1);
vm.selectFork(forkOf[10]);
assertEq(vm.getChainId(), 10);
}
function test_configExists() public {
_loadConfig("./test/fixtures/config.toml", false);
string[] memory keys = new string[](7);
keys[0] = "is_live";
keys[1] = "weth";
keys[2] = "word";
keys[3] = "number";
keys[4] = "signed_number";
keys[5] = "b";
keys[6] = "str";
// Read and assert RPC URL for Mainnet (chain ID 1)
assertEq(config.getRpcUrl(1), "https://ethereum.reth.rs/rpc");
for (uint256 i = 0; i < keys.length; ++i) {
assertTrue(config.exists(1, keys[i]));
assertFalse(config.exists(1, string.concat(keys[i], "_")));
}
// Assert RPC URL for Optimism (chain ID 10)
assertEq(config.getRpcUrl(10), "https://mainnet.optimism.io");
for (uint256 i = 0; i < keys.length; ++i) {
assertTrue(config.exists(10, keys[i]));
assertFalse(config.exists(10, string.concat(keys[i], "_")));
}
}
function test_writeConfig() public {
// Create a temporary copy of the config file to avoid modifying the original.
string memory originalConfig = "./test/fixtures/config.toml";
string memory testConfig = "./test/fixtures/config.t.toml";
vm.copyFile(originalConfig, testConfig);
// Deploy the config contract with the temporary fixture.
_loadConfig(testConfig, false);
// Enable writing to file bypassing the context check.
vm.store(address(config), bytes32(uint256(5)), bytes32(uint256(1)));
{
// Update a single boolean value and verify the change.
config.set(1, "is_live", false);
assertFalse(config.get(1, "is_live").toBool());
string memory content = vm.readFile(testConfig);
assertFalse(vm.parseTomlBool(content, "$.mainnet.bool.is_live"));
// Update a single address value and verify the change.
address new_addr = 0xDeaDbeefdEAdbeefdEadbEEFdeadbeEFdEaDbeeF;
config.set(1, "weth", new_addr);
assertEq(config.get(1, "weth").toAddress(), new_addr);
content = vm.readFile(testConfig);
assertEq(vm.parseTomlAddress(content, "$.mainnet.address.weth"), new_addr);
// Update a uint array and verify the change.
uint256[] memory new_numbers = new uint256[](3);
new_numbers[0] = 1;
new_numbers[1] = 2;
new_numbers[2] = 3;
config.set(10, "number_array", new_numbers);
uint256[] memory updated_numbers_mem = config.get(10, "number_array").toUint256Array();
assertEq(updated_numbers_mem.length, 3);
assertEq(updated_numbers_mem[0], 1);
assertEq(updated_numbers_mem[1], 2);
assertEq(updated_numbers_mem[2], 3);
content = vm.readFile(testConfig);
uint256[] memory updated_numbers_disk = vm.parseTomlUintArray(content, "$.optimism.uint.number_array");
assertEq(updated_numbers_disk.length, 3);
assertEq(updated_numbers_disk[0], 1);
assertEq(updated_numbers_disk[1], 2);
assertEq(updated_numbers_disk[2], 3);
// Update a string array and verify the change.
string[] memory new_strings = new string[](2);
new_strings[0] = "hello";
new_strings[1] = "world";
config.set(1, "str_array", new_strings);
string[] memory updated_strings_mem = config.get(1, "str_array").toStringArray();
assertEq(updated_strings_mem.length, 2);
assertEq(updated_strings_mem[0], "hello");
assertEq(updated_strings_mem[1], "world");
content = vm.readFile(testConfig);
string[] memory updated_strings_disk = vm.parseTomlStringArray(content, "$.mainnet.string.str_array");
assertEq(updated_strings_disk.length, 2);
assertEq(updated_strings_disk[0], "hello");
assertEq(updated_strings_disk[1], "world");
// Create a new uint variable and verify the change.
config.set(1, "new_uint", uint256(42));
assertEq(config.get(1, "new_uint").toUint256(), 42);
content = vm.readFile(testConfig);
assertEq(vm.parseTomlUint(content, "$.mainnet.uint.new_uint"), 42);
// Create a new int variable and verify the change.
config.set(1, "new_int", int256(-42));
assertEq(config.get(1, "new_int").toInt256(), -42);
content = vm.readFile(testConfig);
assertEq(vm.parseTomlInt(content, "$.mainnet.int.new_int"), -42);
// Create a new int array and verify the change.
int256[] memory new_ints = new int256[](2);
new_ints[0] = -100;
new_ints[1] = 200;
config.set(10, "new_ints", new_ints);
int256[] memory updated_ints_mem = config.get(10, "new_ints").toInt256Array();
assertEq(updated_ints_mem.length, 2);
assertEq(updated_ints_mem[0], -100);
assertEq(updated_ints_mem[1], 200);
content = vm.readFile(testConfig);
int256[] memory updated_ints_disk = vm.parseTomlIntArray(content, "$.optimism.int.new_ints");
assertEq(updated_ints_disk.length, 2);
assertEq(updated_ints_disk[0], -100);
assertEq(updated_ints_disk[1], 200);
// Create a new bytes32 array and verify the change.
bytes32[] memory new_words = new bytes32[](2);
new_words[0] = bytes32(uint256(0xDEAD));
new_words[1] = bytes32(uint256(0xBEEF));
config.set(10, "new_words", new_words);
bytes32[] memory updated_words_mem = config.get(10, "new_words").toBytes32Array();
assertEq(updated_words_mem.length, 2);
assertEq(updated_words_mem[0], new_words[0]);
assertEq(updated_words_mem[1], new_words[1]);
content = vm.readFile(testConfig);
bytes32[] memory updated_words_disk = vm.parseTomlBytes32Array(content, "$.optimism.bytes32.new_words");
assertEq(updated_words_disk.length, 2);
assertEq(vm.toString(updated_words_disk[0]), vm.toString(new_words[0]));
assertEq(vm.toString(updated_words_disk[1]), vm.toString(new_words[1]));
}
// Clean up the temporary file.
vm.removeFile(testConfig);
}
function test_writeUpdatesBackToFile() public {
// Create a temporary copy of the config file to avoid modifying the original.
string memory originalConfig = "./test/fixtures/config.toml";
string memory testConfig = "./test/fixtures/write_config.t.toml";
vm.copyFile(originalConfig, testConfig);
// Deploy the config contract with `writeToFile = false` (disabled).
_loadConfig(testConfig, false);
// Update a single boolean value and verify the file is NOT changed.
config.set(1, "is_live", false);
string memory content = vm.readFile(testConfig);
assertTrue(vm.parseTomlBool(content, "$.mainnet.bool.is_live"), "File should not be updated yet");
// Enable writing to file bypassing the context check.
vm.store(address(config), bytes32(uint256(5)), bytes32(uint256(1)));
// Update the value again and verify the file IS changed.
config.set(1, "is_live", false);
content = vm.readFile(testConfig);
assertFalse(vm.parseTomlBool(content, "$.mainnet.bool.is_live"), "File should be updated now");
// Disable writing to file.
config.writeUpdatesBackToFile(false);
// Update the value again and verify the file is NOT changed.
config.set(1, "is_live", true);
content = vm.readFile(testConfig);
assertFalse(vm.parseTomlBool(content, "$.mainnet.bool.is_live"), "File should not be updated again");
// Clean up the temporary file.
vm.removeFile(testConfig);
}
function testRevert_WriteToFileInForbiddenCtxt() public {
// Cannot initialize enabling writing to file unless we are in SCRIPT mode.
vm.expectRevert(StdConfig.WriteToFileInForbiddenCtxt.selector);
_loadConfig("./test/fixtures/config.toml", true);
// Initialize with `writeToFile = false`.
_loadConfig("./test/fixtures/config.toml", false);
// Cannot enable writing to file unless we are in SCRIPT mode.
vm.expectRevert(StdConfig.WriteToFileInForbiddenCtxt.selector);
config.writeUpdatesBackToFile(true);
}
function testRevert_InvalidChainKey() public {
// Create a fixture with an invalid chain key
string memory invalidChainConfig = "./test/fixtures/config_invalid_chain.toml";
vm.writeFile(
invalidChainConfig,
string.concat(
"[mainnet]\n",
"endpoint_url = \"https://ethereum.reth.rs/rpc\"\n",
"\n",
"[mainnet.uint]\n",
"valid_number = 123\n",
"\n",
"# Invalid chain key (not a number and not a valid alias)\n",
"[invalid_chain]\n",
"endpoint_url = \"https://invalid.com\"\n",
"\n",
"[invalid_chain_9999.uint]\n",
"some_value = 456\n"
)
);
vm.expectRevert(abi.encodeWithSelector(StdConfig.InvalidChainKey.selector, "invalid_chain"));
new StdConfig(invalidChainConfig, false);
vm.removeFile(invalidChainConfig);
}
function testRevert_ChainNotInitialized() public {
_loadConfig("./test/fixtures/config.toml", false);
// Enable writing to file bypassing the context check.
vm.store(address(config), bytes32(uint256(5)), bytes32(uint256(1)));
// Try to write a value for a non-existent chain ID
vm.expectRevert(abi.encodeWithSelector(StdConfig.ChainNotInitialized.selector, uint256(999999)));
config.set(999999, "some_key", uint256(123));
}
function testRevert_UnableToParseVariable() public {
// Create a temporary fixture with an unparsable variable
string memory badParseConfig = "./test/fixtures/config_bad_parse.toml";
vm.writeFile(
badParseConfig,
string.concat(
"[mainnet]\n",
"endpoint_url = \"https://ethereum.reth.rs/rpc\"\n",
"\n",
"[mainnet.uint]\n",
"bad_value = \"not_a_number\"\n"
)
);
vm.expectRevert(abi.encodeWithSelector(StdConfig.UnableToParseVariable.selector, "bad_value"));
new StdConfig(badParseConfig, false);
vm.removeFile(badParseConfig);
}
}

452
packages/contracts/lib/forge-std/test/LibVariable.t.sol Normal file
View file

@ -0,0 +1,452 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity ^0.8.13;
import {Test} from "../src/Test.sol";
import {Variable, Type, TypeKind, LibVariable} from "../src/LibVariable.sol";
contract LibVariableTest is Test {
using LibVariable for Type;
using LibVariable for TypeKind;
LibVariableHelper internal helper;
bytes internal expectedErr;
Variable internal uninitVar;
Variable internal boolVar;
Variable internal addressVar;
Variable internal bytes32Var;
Variable internal uintVar;
Variable internal intVar;
Variable internal stringVar;
Variable internal bytesVar;
Variable internal boolArrayVar;
Variable internal addressArrayVar;
Variable internal bytes32ArrayVar;
Variable internal uintArrayVar;
Variable internal intArrayVar;
Variable internal stringArrayVar;
Variable internal bytesArrayVar;
function setUp() public {
helper = new LibVariableHelper();
// UNINITIALIZED
uninitVar = Variable(Type(TypeKind.None, false), "");
// SINGLE VALUES
boolVar = Variable(Type(TypeKind.Bool, false), abi.encode(true));
addressVar = Variable(Type(TypeKind.Address, false), abi.encode(address(0xdeadbeef)));
bytes32Var = Variable(Type(TypeKind.Bytes32, false), abi.encode(bytes32(uint256(42))));
uintVar = Variable(Type(TypeKind.Uint256, false), abi.encode(uint256(123)));
intVar = Variable(Type(TypeKind.Int256, false), abi.encode(int256(-123)));
stringVar = Variable(Type(TypeKind.String, false), abi.encode("hello world"));
bytesVar = Variable(Type(TypeKind.Bytes, false), abi.encode(hex"c0ffee"));
// ARRAY VALUES
bool[] memory bools = new bool[](2);
bools[0] = true;
bools[1] = false;
boolArrayVar = Variable(Type(TypeKind.Bool, true), abi.encode(bools));
address[] memory addrs = new address[](2);
addrs[0] = address(0x1);
addrs[1] = address(0x2);
addressArrayVar = Variable(Type(TypeKind.Address, true), abi.encode(addrs));
bytes32[] memory b32s = new bytes32[](2);
b32s[0] = bytes32(uint256(1));
b32s[1] = bytes32(uint256(2));
bytes32ArrayVar = Variable(Type(TypeKind.Bytes32, true), abi.encode(b32s));
uint256[] memory uints = new uint256[](2);
uints[0] = 1;
uints[1] = 2;
uintArrayVar = Variable(Type(TypeKind.Uint256, true), abi.encode(uints));
int256[] memory ints = new int256[](2);
ints[0] = -1;
ints[1] = 2;
intArrayVar = Variable(Type(TypeKind.Int256, true), abi.encode(ints));
string[] memory strings = new string[](2);
strings[0] = "one";
strings[1] = "two";
stringArrayVar = Variable(Type(TypeKind.String, true), abi.encode(strings));
bytes[] memory b = new bytes[](2);
b[0] = hex"01";
b[1] = hex"02";
bytesArrayVar = Variable(Type(TypeKind.Bytes, true), abi.encode(b));
}
// -- SUCCESS CASES --------------------------------------------------------
function test_TypeHelpers() public view {
// TypeKind.toString()
assertEq(TypeKind.None.toString(), "none");
assertEq(TypeKind.Bool.toString(), "bool");
assertEq(TypeKind.Address.toString(), "address");
assertEq(TypeKind.Bytes32.toString(), "bytes32");
assertEq(TypeKind.Uint256.toString(), "uint256");
assertEq(TypeKind.Int256.toString(), "int256");
assertEq(TypeKind.String.toString(), "string");
assertEq(TypeKind.Bytes.toString(), "bytes");
// TypeKind.toTomlKey()
assertEq(TypeKind.Uint256.toTomlKey(), "uint");
assertEq(TypeKind.Int256.toTomlKey(), "int");
assertEq(TypeKind.Bytes32.toTomlKey(), "bytes32");
// Type.toString()
assertEq(boolVar.ty.toString(), "bool");
assertEq(boolArrayVar.ty.toString(), "bool[]");
assertEq(uintVar.ty.toString(), "uint256");
assertEq(uintArrayVar.ty.toString(), "uint256[]");
assertEq(uninitVar.ty.toString(), "none");
// Type.isEqual()
assertTrue(boolVar.ty.isEqual(Type(TypeKind.Bool, false)));
assertFalse(boolVar.ty.isEqual(Type(TypeKind.Bool, true)));
assertFalse(boolVar.ty.isEqual(Type(TypeKind.Address, false)));
// Type.assertEq()
boolVar.ty.assertEq(Type(TypeKind.Bool, false));
uintArrayVar.ty.assertEq(Type(TypeKind.Uint256, true));
}
function test_Coercion() public view {
// Single values
assertTrue(helper.toBool(boolVar));
assertEq(helper.toAddress(addressVar), address(0xdeadbeef));
assertEq(helper.toBytes32(bytes32Var), bytes32(uint256(42)));
assertEq(helper.toUint256(uintVar), 123);
assertEq(helper.toInt256(intVar), -123);
assertEq(helper.toString(stringVar), "hello world");
assertEq(helper.toBytes(bytesVar), hex"c0ffee");
// Bool array
bool[] memory bools = helper.toBoolArray(boolArrayVar);
assertEq(bools.length, 2);
assertTrue(bools[0]);
assertFalse(bools[1]);
// Address array
address[] memory addrs = helper.toAddressArray(addressArrayVar);
assertEq(addrs.length, 2);
assertEq(addrs[0], address(0x1));
assertEq(addrs[1], address(0x2));
// String array
string[] memory strings = helper.toStringArray(stringArrayVar);
assertEq(strings.length, 2);
assertEq(strings[0], "one");
assertEq(strings[1], "two");
// Bytes32 array
bytes32[] memory b32s = helper.toBytes32Array(bytes32ArrayVar);
assertEq(b32s.length, 2);
assertEq(b32s[0], bytes32(uint256(1)));
assertEq(b32s[1], bytes32(uint256(2)));
// Int array
int256[] memory ints = helper.toInt256Array(intArrayVar);
assertEq(ints.length, 2);
assertEq(ints[0], -1);
assertEq(ints[1], 2);
// Bytes array
bytes[] memory b = helper.toBytesArray(bytesArrayVar);
assertEq(b.length, 2);
assertEq(b[0], hex"01");
assertEq(b[1], hex"02");
}
function test_Downcasting() public view {
// Uint downcasting
Variable memory v_uint_small = Variable(Type(TypeKind.Uint256, false), abi.encode(uint256(100)));
assertEq(helper.toUint128(v_uint_small), 100);
assertEq(helper.toUint64(v_uint_small), 100);
assertEq(helper.toUint32(v_uint_small), 100);
assertEq(helper.toUint16(v_uint_small), 100);
assertEq(helper.toUint8(v_uint_small), 100);
// Uint array downcasting
uint256[] memory small_uints = new uint256[](2);
small_uints[0] = 10;
small_uints[1] = 20;
Variable memory v_uint_array_small = Variable(Type(TypeKind.Uint256, true), abi.encode(small_uints));
uint8[] memory u8_array = helper.toUint8Array(v_uint_array_small);
assertEq(u8_array[0], 10);
assertEq(u8_array[1], 20);
// Int downcasting
Variable memory v_int_small_pos = Variable(Type(TypeKind.Int256, false), abi.encode(int256(100)));
Variable memory v_int_small_neg = Variable(Type(TypeKind.Int256, false), abi.encode(int256(-100)));
assertEq(helper.toInt128(v_int_small_pos), 100);
assertEq(helper.toInt64(v_int_small_neg), -100);
assertEq(helper.toInt32(v_int_small_pos), 100);
assertEq(helper.toInt16(v_int_small_neg), -100);
assertEq(helper.toInt8(v_int_small_pos), 100);
// Int array downcasting
int256[] memory small_ints = new int256[](2);
small_ints[0] = -10;
small_ints[1] = 20;
Variable memory intArraySmall = Variable(Type(TypeKind.Int256, true), abi.encode(small_ints));
int8[] memory i8_array = helper.toInt8Array(intArraySmall);
assertEq(i8_array[0], -10);
assertEq(i8_array[1], 20);
}
// -- REVERT CASES ---------------------------------------------------------
function testRevert_NotInitialized() public {
vm.expectRevert(LibVariable.NotInitialized.selector);
helper.toBool(uninitVar);
vm.expectRevert(LibVariable.NotInitialized.selector);
helper.toAddressArray(uninitVar);
}
function testRevert_assertExists() public {
vm.expectRevert(LibVariable.NotInitialized.selector);
helper.assertExists(uninitVar);
}
function testRevert_TypeMismatch() public {
// Single values
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "uint256", "bool"));
helper.toUint256(boolVar);
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "address", "string"));
helper.toAddress(stringVar);
// Arrays
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "uint256[]", "bool[]"));
helper.toUint256Array(boolArrayVar);
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "address[]", "string[]"));
helper.toAddressArray(stringArrayVar);
// Single value to array
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "bool[]", "bool"));
helper.toBoolArray(boolVar);
// Array to single value
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "bool", "bool[]"));
helper.toBool(boolArrayVar);
// assertEq reverts
vm.expectRevert(abi.encodeWithSelector(LibVariable.TypeMismatch.selector, "uint256", "bool"));
helper.assertEq(boolVar.ty, Type(TypeKind.Uint256, false));
}
function testRevert_UnsafeCast() public {
// uint overflow
Variable memory uintLarge = Variable(Type(TypeKind.Uint256, false), abi.encode(uint256(type(uint128).max) + 1));
expectedErr = abi.encodeWithSelector(LibVariable.UnsafeCast.selector, "value does not fit in 'uint128'");
vm.expectRevert(expectedErr);
helper.toUint128(uintLarge);
// int overflow
Variable memory intLarge = Variable(Type(TypeKind.Int256, false), abi.encode(int256(type(int128).max) + 1));
expectedErr = abi.encodeWithSelector(LibVariable.UnsafeCast.selector, "value does not fit in 'int128'");
vm.expectRevert(expectedErr);
helper.toInt128(intLarge);
// int underflow
Variable memory intSmall = Variable(Type(TypeKind.Int256, false), abi.encode(int256(type(int128).min) - 1));
expectedErr = abi.encodeWithSelector(LibVariable.UnsafeCast.selector, "value does not fit in 'int128'");
vm.expectRevert(expectedErr);
helper.toInt128(intSmall);
// uint array overflow
uint256[] memory uintArray = new uint256[](2);
uintArray[0] = 10;
uintArray[1] = uint256(type(uint64).max) + 1;
Variable memory uintArrayLarge = Variable(Type(TypeKind.Uint256, true), abi.encode(uintArray));
expectedErr = abi.encodeWithSelector(LibVariable.UnsafeCast.selector, "value in array does not fit in 'uint64'");
vm.expectRevert(expectedErr);
helper.toUint64Array(uintArrayLarge);
// int array overflow
int256[] memory intArray = new int256[](2);
intArray[0] = 10;
intArray[1] = int256(type(int64).max) + 1;
Variable memory intArrayLarge = Variable(Type(TypeKind.Int256, true), abi.encode(intArray));
expectedErr = abi.encodeWithSelector(LibVariable.UnsafeCast.selector, "value in array does not fit in 'int64'");
vm.expectRevert(expectedErr);
helper.toInt64Array(intArrayLarge);
// int array underflow
intArray[0] = 10;
intArray[1] = int256(type(int64).min) - 1;
Variable memory intArraySmall = Variable(Type(TypeKind.Int256, true), abi.encode(intArray));
expectedErr = abi.encodeWithSelector(LibVariable.UnsafeCast.selector, "value in array does not fit in 'int64'");
vm.expectRevert(expectedErr);
helper.toInt64Array(intArraySmall);
}
}
/// @dev We must use an external helper contract to ensure proper call depth for `vm.expectRevert`,
/// as direct library calls are inlined by the compiler, causing call depth issues.
contract LibVariableHelper {
using LibVariable for Type;
using LibVariable for TypeKind;
// Assertions
function assertExists(Variable memory v) external pure {
v.assertExists();
}
function assertEq(Type memory t1, Type memory t2) external pure {
t1.assertEq(t2);
}
// Single Value Coercion
function toBool(Variable memory v) external pure returns (bool) {
return v.toBool();
}
function toAddress(Variable memory v) external pure returns (address) {
return v.toAddress();
}
function toBytes32(Variable memory v) external pure returns (bytes32) {
return v.toBytes32();
}
function toUint256(Variable memory v) external pure returns (uint256) {
return v.toUint256();
}
function toInt256(Variable memory v) external pure returns (int256) {
return v.toInt256();
}
function toString(Variable memory v) external pure returns (string memory) {
return v.toString();
}
function toBytes(Variable memory v) external pure returns (bytes memory) {
return v.toBytes();
}
// Array Coercion
function toBoolArray(Variable memory v) external pure returns (bool[] memory) {
return v.toBoolArray();
}
function toAddressArray(Variable memory v) external pure returns (address[] memory) {
return v.toAddressArray();
}
function toBytes32Array(Variable memory v) external pure returns (bytes32[] memory) {
return v.toBytes32Array();
}
function toUint256Array(Variable memory v) external pure returns (uint256[] memory) {
return v.toUint256Array();
}
function toInt256Array(Variable memory v) external pure returns (int256[] memory) {
return v.toInt256Array();
}
function toStringArray(Variable memory v) external pure returns (string[] memory) {
return v.toStringArray();
}
function toBytesArray(Variable memory v) external pure returns (bytes[] memory) {
return v.toBytesArray();
}
// Uint Downcasting
function toUint128(Variable memory v) external pure returns (uint128) {
return v.toUint128();
}
function toUint64(Variable memory v) external pure returns (uint64) {
return v.toUint64();
}
function toUint32(Variable memory v) external pure returns (uint32) {
return v.toUint32();
}
function toUint16(Variable memory v) external pure returns (uint16) {
return v.toUint16();
}
function toUint8(Variable memory v) external pure returns (uint8) {
return v.toUint8();
}
// Int Downcasting
function toInt128(Variable memory v) external pure returns (int128) {
return v.toInt128();
}
function toInt64(Variable memory v) external pure returns (int64) {
return v.toInt64();
}
function toInt32(Variable memory v) external pure returns (int32) {
return v.toInt32();
}
function toInt16(Variable memory v) external pure returns (int16) {
return v.toInt16();
}
function toInt8(Variable memory v) external pure returns (int8) {
return v.toInt8();
}
// Uint Array Downcasting
function toUint128Array(Variable memory v) external pure returns (uint128[] memory) {
return v.toUint128Array();
}
function toUint64Array(Variable memory v) external pure returns (uint64[] memory) {
return v.toUint64Array();
}
function toUint32Array(Variable memory v) external pure returns (uint32[] memory) {
return v.toUint32Array();
}
function toUint16Array(Variable memory v) external pure returns (uint16[] memory) {
return v.toUint16Array();
}
function toUint8Array(Variable memory v) external pure returns (uint8[] memory) {
return v.toUint8Array();
}
// Int Array Downcasting
function toInt128Array(Variable memory v) external pure returns (int128[] memory) {
return v.toInt128Array();
}
function toInt64Array(Variable memory v) external pure returns (int64[] memory) {
return v.toInt64Array();
}
function toInt32Array(Variable memory v) external pure returns (int32[] memory) {
return v.toInt32Array();
}
function toInt16Array(Variable memory v) external pure returns (int16[] memory) {
return v.toInt16Array();
}
function toInt8Array(Variable memory v) external pure returns (int8[] memory) {
return v.toInt8Array();
}
}

141
packages/contracts/lib/forge-std/test/StdAssertions.t.sol Normal file
View file

@ -0,0 +1,141 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {StdAssertions} from "../src/StdAssertions.sol";
import {Vm} from "../src/Vm.sol";
interface VmInternal is Vm {
function _expectCheatcodeRevert(bytes memory message) external;
}
contract StdAssertionsTest is StdAssertions {
string constant errorMessage = "User provided message";
uint256 constant maxDecimals = 77;
bool constant SHOULD_REVERT = true;
bool constant SHOULD_RETURN = false;
bool constant STRICT_REVERT_DATA = true;
bool constant NON_STRICT_REVERT_DATA = false;
VmInternal constant vm = VmInternal(address(uint160(uint256(keccak256("hevm cheat code")))));
function testFuzz_AssertEqCall_Return_Pass(
bytes memory callDataA,
bytes memory callDataB,
bytes memory returnData,
bool strictRevertData
) external {
address targetA = address(new TestMockCall(returnData, SHOULD_RETURN));
address targetB = address(new TestMockCall(returnData, SHOULD_RETURN));
assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData);
}
function testFuzz_RevertWhenCalled_AssertEqCall_Return_Fail(
bytes memory callDataA,
bytes memory callDataB,
bytes memory returnDataA,
bytes memory returnDataB,
bool strictRevertData
) external {
vm.assume(keccak256(returnDataA) != keccak256(returnDataB));
address targetA = address(new TestMockCall(returnDataA, SHOULD_RETURN));
address targetB = address(new TestMockCall(returnDataB, SHOULD_RETURN));
vm._expectCheatcodeRevert(
bytes(
string.concat(
"Call return data does not match: ", vm.toString(returnDataA), " != ", vm.toString(returnDataB)
)
)
);
assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData);
}
function testFuzz_AssertEqCall_Revert_Pass(
bytes memory callDataA,
bytes memory callDataB,
bytes memory revertDataA,
bytes memory revertDataB
) external {
address targetA = address(new TestMockCall(revertDataA, SHOULD_REVERT));
address targetB = address(new TestMockCall(revertDataB, SHOULD_REVERT));
assertEqCall(targetA, callDataA, targetB, callDataB, NON_STRICT_REVERT_DATA);
}
function testFuzz_RevertWhenCalled_AssertEqCall_Revert_Fail(
bytes memory callDataA,
bytes memory callDataB,
bytes memory revertDataA,
bytes memory revertDataB
) external {
vm.assume(keccak256(revertDataA) != keccak256(revertDataB));
address targetA = address(new TestMockCall(revertDataA, SHOULD_REVERT));
address targetB = address(new TestMockCall(revertDataB, SHOULD_REVERT));
vm._expectCheatcodeRevert(
bytes(
string.concat(
"Call revert data does not match: ", vm.toString(revertDataA), " != ", vm.toString(revertDataB)
)
)
);
assertEqCall(targetA, callDataA, targetB, callDataB, STRICT_REVERT_DATA);
}
function testFuzz_RevertWhenCalled_AssertEqCall_Fail(
bytes memory callDataA,
bytes memory callDataB,
bytes memory returnDataA,
bytes memory returnDataB,
bool strictRevertData
) external {
address targetA = address(new TestMockCall(returnDataA, SHOULD_RETURN));
address targetB = address(new TestMockCall(returnDataB, SHOULD_REVERT));
vm.expectRevert(bytes("assertion failed"));
this.assertEqCallExternal(targetA, callDataA, targetB, callDataB, strictRevertData);
vm.expectRevert(bytes("assertion failed"));
this.assertEqCallExternal(targetB, callDataB, targetA, callDataA, strictRevertData);
}
// Helper function to test outcome of assertEqCall via `expect` cheatcodes
function assertEqCallExternal(
address targetA,
bytes memory callDataA,
address targetB,
bytes memory callDataB,
bool strictRevertData
) public {
assertEqCall(targetA, callDataA, targetB, callDataB, strictRevertData);
}
}
contract TestMockCall {
bytes returnData;
bool shouldRevert;
constructor(bytes memory returnData_, bool shouldRevert_) {
returnData = returnData_;
shouldRevert = shouldRevert_;
}
fallback() external payable {
bytes memory returnData_ = returnData;
if (shouldRevert) {
assembly {
revert(add(returnData_, 0x20), mload(returnData_))
}
} else {
assembly {
return(add(returnData_, 0x20), mload(returnData_))
}
}
}
}

227
packages/contracts/lib/forge-std/test/StdChains.t.sol Normal file
View file

@ -0,0 +1,227 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test} from "../src/Test.sol";
contract StdChainsMock is Test {
function exposedGetChain(string memory chainAlias) public returns (Chain memory) {
return getChain(chainAlias);
}
function exposedGetChain(uint256 chainId) public returns (Chain memory) {
return getChain(chainId);
}
function exposedSetChain(string memory chainAlias, ChainData memory chainData) public {
setChain(chainAlias, chainData);
}
function exposedSetFallbackToDefaultRpcUrls(bool useDefault) public {
setFallbackToDefaultRpcUrls(useDefault);
}
}
contract StdChainsTest is Test {
function test_ChainRpcInitialization() public {
// RPCs specified in `foundry.toml` should be updated.
assertEq(getChain(1).rpcUrl, "https://ethereum.reth.rs/rpc");
assertEq(getChain("optimism_sepolia").rpcUrl, "https://sepolia.optimism.io/");
assertEq(getChain("arbitrum_one_sepolia").rpcUrl, "https://sepolia-rollup.arbitrum.io/rpc/");
// Environment variables should be the next fallback
assertEq(getChain("arbitrum_nova").rpcUrl, "https://nova.arbitrum.io/rpc");
vm.setEnv("ARBITRUM_NOVA_RPC_URL", "myoverride");
assertEq(getChain("arbitrum_nova").rpcUrl, "myoverride");
vm.setEnv("ARBITRUM_NOVA_RPC_URL", "https://nova.arbitrum.io/rpc");
// Cannot override RPCs defined in `foundry.toml`
vm.setEnv("MAINNET_RPC_URL", "myoverride2");
assertEq(getChain("mainnet").rpcUrl, "https://ethereum.reth.rs/rpc");
// Other RPCs should remain unchanged.
assertEq(getChain(31337).rpcUrl, "http://127.0.0.1:8545");
assertEq(getChain("sepolia").rpcUrl, "https://sepolia.infura.io/v3/b9794ad1ddf84dfb8c34d6bb5dca2001");
}
// Named with a leading underscore to clarify this is not intended to be run as a normal test,
// and is intended to be used in the below `test_Rpcs` test.
function _testRpc(string memory rpcAlias) internal {
string memory rpcUrl = getChain(rpcAlias).rpcUrl;
vm.createSelectFork(rpcUrl);
}
// Ensure we can connect to the default RPC URL for each chain.
// Currently commented out since this is slow and public RPCs are flaky, often resulting in failing CI.
// function test_Rpcs() public {
// _testRpc("mainnet");
// _testRpc("sepolia");
// _testRpc("holesky");
// _testRpc("optimism");
// _testRpc("optimism_sepolia");
// _testRpc("arbitrum_one");
// _testRpc("arbitrum_one_sepolia");
// _testRpc("arbitrum_nova");
// _testRpc("polygon");
// _testRpc("polygon_amoy");
// _testRpc("avalanche");
// _testRpc("avalanche_fuji");
// _testRpc("bnb_smart_chain");
// _testRpc("bnb_smart_chain_testnet");
// _testRpc("gnosis_chain");
// _testRpc("moonbeam");
// _testRpc("moonriver");
// _testRpc("moonbase");
// _testRpc("base_sepolia");
// _testRpc("base");
// _testRpc("blast_sepolia");
// _testRpc("blast");
// _testRpc("fantom_opera");
// _testRpc("fantom_opera_testnet");
// _testRpc("fraxtal");
// _testRpc("fraxtal_testnet");
// _testRpc("berachain_bartio_testnet");
// _testRpc("flare");
// _testRpc("flare_coston2");
// }
function test_RevertIf_ChainNotFound() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains getChain(string): Chain with alias \"does_not_exist\" not found.");
stdChainsMock.exposedGetChain("does_not_exist");
}
function test_RevertIf_SetChain_ChainIdExist_FirstTest() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains setChain(string,ChainData): Chain ID 31337 already used by \"anvil\".");
stdChainsMock.exposedSetChain("anvil2", ChainData("Anvil", 31337, "URL"));
}
function test_RevertIf_ChainBubbleUp() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
stdChainsMock.exposedSetChain("needs_undefined_env_var", ChainData("", 123456789, ""));
// Forge environment variable error.
vm.expectRevert();
stdChainsMock.exposedGetChain("needs_undefined_env_var");
}
function test_RevertIf_SetChain_ChainIdExists_SecondTest() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
stdChainsMock.exposedSetChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/"));
vm.expectRevert('StdChains setChain(string,ChainData): Chain ID 123456789 already used by "custom_chain".');
stdChainsMock.exposedSetChain("another_custom_chain", ChainData("", 123456789, ""));
}
function test_SetChain() public {
setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/"));
Chain memory customChain = getChain("custom_chain");
assertEq(customChain.name, "Custom Chain");
assertEq(customChain.chainId, 123456789);
assertEq(customChain.chainAlias, "custom_chain");
assertEq(customChain.rpcUrl, "https://custom.chain/");
Chain memory chainById = getChain(123456789);
assertEq(chainById.name, customChain.name);
assertEq(chainById.chainId, customChain.chainId);
assertEq(chainById.chainAlias, customChain.chainAlias);
assertEq(chainById.rpcUrl, customChain.rpcUrl);
customChain.name = "Another Custom Chain";
customChain.chainId = 987654321;
setChain("another_custom_chain", customChain);
Chain memory anotherCustomChain = getChain("another_custom_chain");
assertEq(anotherCustomChain.name, "Another Custom Chain");
assertEq(anotherCustomChain.chainId, 987654321);
assertEq(anotherCustomChain.chainAlias, "another_custom_chain");
assertEq(anotherCustomChain.rpcUrl, "https://custom.chain/");
// Verify the first chain data was not overwritten
chainById = getChain(123456789);
assertEq(chainById.name, "Custom Chain");
assertEq(chainById.chainId, 123456789);
}
function test_RevertIf_SetEmptyAlias() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains setChain(string,ChainData): Chain alias cannot be the empty string.");
stdChainsMock.exposedSetChain("", ChainData("", 123456789, ""));
}
function test_RevertIf_SetNoChainId0() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains setChain(string,ChainData): Chain ID cannot be 0.");
stdChainsMock.exposedSetChain("alias", ChainData("", 0, ""));
}
function test_RevertIf_GetNoChainId0() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains getChain(uint256): Chain ID cannot be 0.");
stdChainsMock.exposedGetChain(0);
}
function test_RevertIf_GetNoEmptyAlias() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains getChain(string): Chain alias cannot be the empty string.");
stdChainsMock.exposedGetChain("");
}
function test_RevertIf_ChainNotInitialized() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains getChain(string): Chain with alias \"no_such_alias\" not found.");
stdChainsMock.exposedGetChain("no_such_alias");
}
function test_RevertIf_ChainAliasNotFound() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
vm.expectRevert("StdChains getChain(uint256): Chain with ID 321 not found.");
stdChainsMock.exposedGetChain(321);
}
function test_SetChain_ExistingOne() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
setChain("custom_chain", ChainData("Custom Chain", 123456789, "https://custom.chain/"));
assertEq(getChain(123456789).chainId, 123456789);
setChain("custom_chain", ChainData("Modified Chain", 9999999999999999999, "https://modified.chain/"));
vm.expectRevert("StdChains getChain(uint256): Chain with ID 123456789 not found.");
stdChainsMock.exposedGetChain(123456789);
Chain memory modifiedChain = getChain(9999999999999999999);
assertEq(modifiedChain.name, "Modified Chain");
assertEq(modifiedChain.chainId, 9999999999999999999);
assertEq(modifiedChain.rpcUrl, "https://modified.chain/");
}
function test_RevertIf_DontUseDefaultRpcUrl() public {
// We deploy a mock to properly test the revert.
StdChainsMock stdChainsMock = new StdChainsMock();
// Should error if default RPCs flag is set to false.
stdChainsMock.exposedSetFallbackToDefaultRpcUrls(false);
vm.expectRevert();
stdChainsMock.exposedGetChain(31337);
vm.expectRevert();
stdChainsMock.exposedGetChain("sepolia");
}
}

695
packages/contracts/lib/forge-std/test/StdCheats.t.sol Normal file
View file

@ -0,0 +1,695 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {StdCheats} from "../src/StdCheats.sol";
import {Test} from "../src/Test.sol";
import {stdJson} from "../src/StdJson.sol";
import {stdToml} from "../src/StdToml.sol";
import {IERC20} from "../src/interfaces/IERC20.sol";
contract StdCheatsTest is Test {
Bar test;
using stdJson for string;
function setUp() public {
test = new Bar();
}
function test_Skip() public {
vm.warp(100);
skip(25);
assertEq(block.timestamp, 125);
}
function test_Rewind() public {
vm.warp(100);
rewind(25);
assertEq(block.timestamp, 75);
}
function test_Hoax() public {
hoax(address(1337));
test.bar{value: 100}(address(1337));
}
function test_HoaxOrigin() public {
hoax(address(1337), address(1337));
test.origin{value: 100}(address(1337));
}
function test_HoaxDifferentAddresses() public {
hoax(address(1337), address(7331));
test.origin{value: 100}(address(1337), address(7331));
}
function test_StartHoax() public {
startHoax(address(1337));
test.bar{value: 100}(address(1337));
test.bar{value: 100}(address(1337));
vm.stopPrank();
test.bar(address(this));
}
function test_StartHoaxOrigin() public {
startHoax(address(1337), address(1337));
test.origin{value: 100}(address(1337));
test.origin{value: 100}(address(1337));
vm.stopPrank();
test.bar(address(this));
}
function test_ChangePrankMsgSender() public {
vm.startPrank(address(1337));
test.bar(address(1337));
changePrank(address(0xdead));
test.bar(address(0xdead));
changePrank(address(1337));
test.bar(address(1337));
vm.stopPrank();
}
function test_ChangePrankMsgSenderAndTxOrigin() public {
vm.startPrank(address(1337), address(1338));
test.origin(address(1337), address(1338));
changePrank(address(0xdead), address(0xbeef));
test.origin(address(0xdead), address(0xbeef));
changePrank(address(1337), address(1338));
test.origin(address(1337), address(1338));
vm.stopPrank();
}
function test_MakeAccountEquivalence() public {
Account memory account = makeAccount("1337");
(address addr, uint256 key) = makeAddrAndKey("1337");
assertEq(account.addr, addr);
assertEq(account.key, key);
}
function test_MakeAddrEquivalence() public {
(address addr,) = makeAddrAndKey("1337");
assertEq(makeAddr("1337"), addr);
}
function test_MakeAddrSigning() public {
(address addr, uint256 key) = makeAddrAndKey("1337");
bytes32 hash = keccak256("some_message");
(uint8 v, bytes32 r, bytes32 s) = vm.sign(key, hash);
assertEq(ecrecover(hash, v, r, s), addr);
}
function test_Deal() public {
deal(address(this), 1 ether);
assertEq(address(this).balance, 1 ether);
}
function test_DealToken() public {
Bar barToken = new Bar();
address bar = address(barToken);
deal(bar, address(this), 10000e18);
assertEq(barToken.balanceOf(address(this)), 10000e18);
}
function test_DealTokenAdjustTotalSupply() public {
Bar barToken = new Bar();
address bar = address(barToken);
deal(bar, address(this), 10000e18, true);
assertEq(barToken.balanceOf(address(this)), 10000e18);
assertEq(barToken.totalSupply(), 20000e18);
deal(bar, address(this), 0, true);
assertEq(barToken.balanceOf(address(this)), 0);
assertEq(barToken.totalSupply(), 10000e18);
}
function test_DealERC1155Token() public {
BarERC1155 barToken = new BarERC1155();
address bar = address(barToken);
dealERC1155(bar, address(this), 0, 10000e18, false);
assertEq(barToken.balanceOf(address(this), 0), 10000e18);
}
function test_DealERC1155TokenAdjustTotalSupply() public {
BarERC1155 barToken = new BarERC1155();
address bar = address(barToken);
dealERC1155(bar, address(this), 0, 10000e18, true);
assertEq(barToken.balanceOf(address(this), 0), 10000e18);
assertEq(barToken.totalSupply(0), 20000e18);
dealERC1155(bar, address(this), 0, 0, true);
assertEq(barToken.balanceOf(address(this), 0), 0);
assertEq(barToken.totalSupply(0), 10000e18);
}
function test_DealERC721Token() public {
BarERC721 barToken = new BarERC721();
address bar = address(barToken);
dealERC721(bar, address(2), 1);
assertEq(barToken.balanceOf(address(2)), 1);
assertEq(barToken.balanceOf(address(1)), 0);
dealERC721(bar, address(1), 2);
assertEq(barToken.balanceOf(address(1)), 1);
assertEq(barToken.balanceOf(bar), 1);
}
function test_DeployCode() public {
address deployed = deployCode("StdCheats.t.sol:Bar", bytes(""));
assertEq(string(getCode(deployed)), string(getCode(address(test))));
}
function test_DestroyAccount() public {
// deploy something to destroy it
BarERC721 barToken = new BarERC721();
address bar = address(barToken);
vm.setNonce(bar, 10);
deal(bar, 100);
uint256 prevThisBalance = address(this).balance;
uint256 size;
assembly {
size := extcodesize(bar)
}
assertGt(size, 0);
assertEq(bar.balance, 100);
assertEq(vm.getNonce(bar), 10);
destroyAccount(bar, address(this));
assembly {
size := extcodesize(bar)
}
assertEq(address(this).balance, prevThisBalance + 100);
assertEq(vm.getNonce(bar), 0);
assertEq(size, 0);
assertEq(bar.balance, 0);
}
function test_DeployCodeNoArgs() public {
address deployed = deployCode("StdCheats.t.sol:Bar");
assertEq(string(getCode(deployed)), string(getCode(address(test))));
}
function test_DeployCodeVal() public {
address deployed = deployCode("StdCheats.t.sol:Bar", bytes(""), 1 ether);
assertEq(string(getCode(deployed)), string(getCode(address(test))));
assertEq(deployed.balance, 1 ether);
}
function test_DeployCodeValNoArgs() public {
address deployed = deployCode("StdCheats.t.sol:Bar", 1 ether);
assertEq(string(getCode(deployed)), string(getCode(address(test))));
assertEq(deployed.balance, 1 ether);
}
// We need this so we can call "this.deployCode" rather than "deployCode" directly
function deployCodeHelper(string memory what) external {
deployCode(what);
}
function test_RevertIf_DeployCodeFail() public {
vm.expectRevert(bytes("StdCheats deployCode(string): Deployment failed."));
this.deployCodeHelper("StdCheats.t.sol:RevertingContract");
}
function getCode(address who) internal view returns (bytes memory o_code) {
assembly ("memory-safe") {
// retrieve the size of the code, this needs assembly
let size := extcodesize(who)
// allocate output byte array - this could also be done without assembly
// by using o_code = new bytes(size)
o_code := mload(0x40)
// new "memory end" including padding
mstore(0x40, add(o_code, and(add(add(size, 0x20), 0x1f), not(0x1f))))
// store length in memory
mstore(o_code, size)
// actually retrieve the code, this needs assembly
extcodecopy(who, add(o_code, 0x20), 0, size)
}
}
function test_DeriveRememberKey() public {
string memory mnemonic = "test test test test test test test test test test test junk";
(address deployer, uint256 privateKey) = deriveRememberKey(mnemonic, 0);
assertEq(deployer, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
assertEq(privateKey, 0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80);
}
function test_BytesToUint() public pure {
assertEq(3, bytesToUint_test(hex"03"));
assertEq(2, bytesToUint_test(hex"02"));
assertEq(255, bytesToUint_test(hex"ff"));
assertEq(29625, bytesToUint_test(hex"73b9"));
}
function test_ParseJsonTxDetail() public view {
string memory root = vm.projectRoot();
string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
string memory json = vm.readFile(path);
bytes memory transactionDetails = json.parseRaw(".transactions[0].tx");
RawTx1559Detail memory rawTxDetail = abi.decode(transactionDetails, (RawTx1559Detail));
Tx1559Detail memory txDetail = rawToConvertedEIP1559Detail(rawTxDetail);
assertEq(txDetail.from, 0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266);
assertEq(txDetail.to, 0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512);
assertEq(
txDetail.data,
hex"23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004"
);
assertEq(txDetail.nonce, 3);
assertEq(txDetail.txType, 2);
assertEq(txDetail.gas, 29625);
assertEq(txDetail.value, 0);
}
function test_ReadEIP1559Transaction() public view {
string memory root = vm.projectRoot();
string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
uint256 index = 0;
Tx1559 memory transaction = readTx1559(path, index);
transaction;
}
function test_ReadEIP1559Transactions() public view {
string memory root = vm.projectRoot();
string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
Tx1559[] memory transactions = readTx1559s(path);
transactions;
}
function test_ReadReceipt() public view {
string memory root = vm.projectRoot();
string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
uint256 index = 5;
Receipt memory receipt = readReceipt(path, index);
assertEq(
receipt.logsBloom,
hex"00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100"
);
}
function test_ReadReceipts() public view {
string memory root = vm.projectRoot();
string memory path = string.concat(root, "/test/fixtures/broadcast.log.json");
Receipt[] memory receipts = readReceipts(path);
receipts;
}
function test_GasMeteringModifier() public {
uint256 gas_start_normal = gasleft();
addInLoop();
uint256 gas_used_normal = gas_start_normal - gasleft();
uint256 gas_start_single = gasleft();
addInLoopNoGas();
uint256 gas_used_single = gas_start_single - gasleft();
uint256 gas_start_double = gasleft();
addInLoopNoGasNoGas();
uint256 gas_used_double = gas_start_double - gasleft();
assertTrue(gas_used_double + gas_used_single < gas_used_normal);
}
function addInLoop() internal pure returns (uint256) {
uint256 b;
for (uint256 i; i < 10000; i++) {
b += i;
}
return b;
}
function addInLoopNoGas() internal noGasMetering returns (uint256) {
return addInLoop();
}
function addInLoopNoGasNoGas() internal noGasMetering returns (uint256) {
return addInLoopNoGas();
}
function bytesToUint_test(bytes memory b) private pure returns (uint256) {
uint256 number;
for (uint256 i = 0; i < b.length; i++) {
number = number + uint256(uint8(b[i])) * (2 ** (8 * (b.length - (i + 1))));
}
return number;
}
function testFuzz_AssumeAddressIsNot(address addr) external {
// skip over Payable and NonPayable enums
for (uint8 i = 2; i < uint8(type(AddressType).max); i++) {
assumeAddressIsNot(addr, AddressType(i));
}
assertTrue(addr != address(0));
assertTrue(addr < address(1) || addr > address(9));
assertTrue(addr != address(vm) || addr != 0x000000000000000000636F6e736F6c652e6c6f67);
}
function test_AssumePayable() external {
// We deploy a mock version so we can properly test the revert.
StdCheatsMock stdCheatsMock = new StdCheatsMock();
// all should revert since these addresses are not payable
// VM address
vm.expectRevert();
stdCheatsMock.exposedAssumePayable(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
// Console address
vm.expectRevert();
stdCheatsMock.exposedAssumePayable(0x000000000000000000636F6e736F6c652e6c6f67);
// Create2Deployer
vm.expectRevert();
stdCheatsMock.exposedAssumePayable(0x4e59b44847b379578588920cA78FbF26c0B4956C);
// all should pass since these addresses are payable
// vitalik.eth
stdCheatsMock.exposedAssumePayable(0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045);
// mock payable contract
MockContractPayable cp = new MockContractPayable();
stdCheatsMock.exposedAssumePayable(address(cp));
}
function test_AssumeNotPayable() external {
// We deploy a mock version so we can properly test the revert.
StdCheatsMock stdCheatsMock = new StdCheatsMock();
// all should pass since these addresses are not payable
// VM address
stdCheatsMock.exposedAssumeNotPayable(0x7109709ECfa91a80626fF3989D68f67F5b1DD12D);
// Console address
stdCheatsMock.exposedAssumeNotPayable(0x000000000000000000636F6e736F6c652e6c6f67);
// Create2Deployer
stdCheatsMock.exposedAssumeNotPayable(0x4e59b44847b379578588920cA78FbF26c0B4956C);
// all should revert since these addresses are payable
// vitalik.eth
vm.expectRevert();
stdCheatsMock.exposedAssumeNotPayable(0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045);
// mock payable contract
MockContractPayable cp = new MockContractPayable();
vm.expectRevert();
stdCheatsMock.exposedAssumeNotPayable(address(cp));
}
function testFuzz_AssumeNotPrecompile(address addr) external {
assumeNotPrecompile(addr, getChain("optimism_sepolia").chainId);
assertTrue(
addr < address(1) || (addr > address(9) && addr < address(0x4200000000000000000000000000000000000000))
|| addr > address(0x4200000000000000000000000000000000000800)
);
}
function testFuzz_AssumeNotForgeAddress(address addr) external pure {
assumeNotForgeAddress(addr);
assertTrue(
addr != address(vm) && addr != 0x000000000000000000636F6e736F6c652e6c6f67
&& addr != 0x4e59b44847b379578588920cA78FbF26c0B4956C
);
}
function test_RevertIf_CannotDeployCodeTo() external {
vm.expectRevert("StdCheats deployCodeTo(string,bytes,uint256,address): Failed to create runtime bytecode.");
this._revertDeployCodeTo();
}
function _revertDeployCodeTo() external {
deployCodeTo("StdCheats.t.sol:RevertingContract", address(0));
}
function test_DeployCodeTo() external {
address arbitraryAddress = makeAddr("arbitraryAddress");
deployCodeTo(
"StdCheats.t.sol:MockContractWithConstructorArgs",
abi.encode(uint256(6), true, bytes20(arbitraryAddress)),
1 ether,
arbitraryAddress
);
MockContractWithConstructorArgs ct = MockContractWithConstructorArgs(arbitraryAddress);
assertEq(arbitraryAddress.balance, 1 ether);
assertEq(ct.x(), 6);
assertTrue(ct.y());
assertEq(ct.z(), bytes20(arbitraryAddress));
}
function test_ExpectAndMockCall() public {
bytes memory data = abi.encodeWithSignature("balanceOf(address)", address(this));
bytes memory returnData = abi.encode(uint256(100));
expectAndMockCall(address(test), data, returnData);
assertEq(test.balanceOf(address(this)), 100);
}
function test_ExpectAndMockCall_Count() public {
bytes memory data = abi.encodeWithSignature("balanceOf(address)", address(this));
bytes memory returnData = abi.encode(uint256(100));
expectAndMockCall(address(test), data, 2, returnData);
assertEq(test.balanceOf(address(this)), 100);
assertEq(test.balanceOf(address(this)), 100);
}
function test_ExpectAndMockCall_MsgValue() public {
bytes memory data = abi.encodeWithSignature("payableBar()");
bytes memory returnData = abi.encode(uint256(100));
expectAndMockCall(address(test), 1 ether, data, returnData);
assertEq(test.payableBar{value: 1 ether}(), 100);
}
function test_ExpectAndMockCall_MsgValueAndCount() public {
bytes memory data = abi.encodeWithSignature("payableBar()");
bytes memory returnData = abi.encode(uint256(100));
expectAndMockCall(address(test), 1 ether, data, 2, returnData);
assertEq(test.payableBar{value: 1 ether}(), 100);
assertEq(test.payableBar{value: 1 ether}(), 100);
}
function test_ExpectAndMockCall_Gas() public {
bytes memory data = abi.encodeWithSignature("payableBar()");
bytes memory returnData = abi.encode(uint256(100));
uint64 gas = 30_000;
expectAndMockCall(address(test), 1 ether, gas, data, returnData);
assertEq(test.payableBar{value: 1 ether, gas: gas}(), 100);
}
function test_ExpectAndMockCall_GasAndCount() public {
bytes memory data = abi.encodeWithSignature("payableBar()");
bytes memory returnData = abi.encode(uint256(100));
uint64 gas = 30_000;
expectAndMockCall(address(test), 1 ether, gas, data, 2, returnData);
assertEq(test.payableBar{value: 1 ether, gas: gas}(), 100);
assertEq(test.payableBar{value: 1 ether, gas: gas}(), 100);
}
}
contract StdCheatsMock is StdCheats {
function exposedAssumePayable(address addr) external {
assumePayable(addr);
}
function exposedAssumeNotPayable(address addr) external {
assumeNotPayable(addr);
}
// We deploy a mock version so we can properly test expected reverts.
function exposedAssumeNotBlacklisted(address token, address addr) external view {
return assumeNotBlacklisted(token, addr);
}
}
contract StdCheatsForkTest is Test {
address internal constant USDC_BLACKLISTED_USER = 0x1E34A77868E19A6647b1f2F47B51ed72dEDE95DD;
address internal constant USDT_BLACKLISTED_USER = 0x8f8a8F4B54a2aAC7799d7bc81368aC27b852822A;
MockUSDT public USDT;
MockUSDC public USDC;
function setUp() public {
USDT = new MockUSDT();
USDC = new MockUSDC();
USDC.setBlacklisted(USDC_BLACKLISTED_USER, true);
USDT.setBlacklisted(USDT_BLACKLISTED_USER, true);
}
function test_RevertIf_CannotAssumeNoBlacklisted_EOA() external {
// We deploy a mock version so we can properly test the revert.
StdCheatsMock stdCheatsMock = new StdCheatsMock();
address eoa = vm.addr({privateKey: 1});
vm.expectRevert("StdCheats assumeNotBlacklisted(address,address): Token address is not a contract.");
stdCheatsMock.exposedAssumeNotBlacklisted(eoa, address(0));
}
function testFuzz_AssumeNotBlacklisted_TokenWithoutBlacklist(address addr) external view {
assumeNotBlacklisted(address(USDC), addr);
assumeNotBlacklisted(address(USDT), addr);
assertTrue(true);
}
function test_RevertIf_AssumeNoBlacklisted_USDC() external {
// We deploy a mock version so we can properly test the revert.
StdCheatsMock stdCheatsMock = new StdCheatsMock();
vm.expectRevert();
stdCheatsMock.exposedAssumeNotBlacklisted(address(USDC), USDC_BLACKLISTED_USER);
}
function testFuzz_AssumeNotBlacklisted_USDC(address addr) external view {
assumeNotBlacklisted(address(USDC), addr);
assertFalse(USDCLike(USDC).isBlacklisted(addr));
}
function test_RevertIf_AssumeNoBlacklisted_USDT() external {
// We deploy a mock version so we can properly test the revert.
StdCheatsMock stdCheatsMock = new StdCheatsMock();
vm.expectRevert();
stdCheatsMock.exposedAssumeNotBlacklisted(address(USDT), USDT_BLACKLISTED_USER);
}
function testFuzz_AssumeNotBlacklisted_USDT(address addr) external view {
assumeNotBlacklisted(address(USDT), addr);
assertFalse(USDTLike(USDT).isBlackListed(addr));
}
}
/// @dev https://etherscan.io/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#readProxyContract
interface USDCLike {
function isBlacklisted(address) external view returns (bool);
}
/// @dev https://etherscan.io/token/0xdac17f958d2ee523a2206206994597c13d831ec7#readContract
interface USDTLike {
function isBlackListed(address) external view returns (bool);
}
contract MockUSDT is USDTLike {
mapping(address => bool) private blacklist;
function isBlackListed(address addr) external view returns (bool) {
return blacklist[addr];
}
function setBlacklisted(address addr, bool value) external {
blacklist[addr] = value;
}
}
contract MockUSDC is USDCLike {
mapping(address => bool) private blacklist;
function isBlacklisted(address addr) external view returns (bool) {
return blacklist[addr];
}
function setBlacklisted(address addr, bool value) external {
blacklist[addr] = value;
}
}
contract Bar {
constructor() payable {
/// `DEAL` STDCHEAT
totalSupply = 10000e18;
balanceOf[address(this)] = totalSupply;
}
/// `HOAX` and `CHANGEPRANK` STDCHEATS
function bar(address expectedSender) public payable {
require(msg.sender == expectedSender, "!prank");
}
function origin(address expectedSender) public payable {
require(msg.sender == expectedSender, "!prank");
require(tx.origin == expectedSender, "!prank");
}
function origin(address expectedSender, address expectedOrigin) public payable {
require(msg.sender == expectedSender, "!prank");
require(tx.origin == expectedOrigin, "!prank");
}
function payableBar() public payable returns (uint256) {
return 0;
}
/// `DEAL` STDCHEAT
mapping(address => uint256) public balanceOf;
uint256 public totalSupply;
}
contract BarERC1155 {
constructor() payable {
/// `DEALERC1155` STDCHEAT
_totalSupply[0] = 10000e18;
_balances[0][address(this)] = _totalSupply[0];
}
function balanceOf(address account, uint256 id) public view virtual returns (uint256) {
return _balances[id][account];
}
function totalSupply(uint256 id) public view virtual returns (uint256) {
return _totalSupply[id];
}
/// `DEALERC1155` STDCHEAT
mapping(uint256 => mapping(address => uint256)) private _balances;
mapping(uint256 => uint256) private _totalSupply;
}
contract BarERC721 {
constructor() payable {
/// `DEALERC721` STDCHEAT
_owners[1] = address(1);
_balances[address(1)] = 1;
_owners[2] = address(this);
_owners[3] = address(this);
_balances[address(this)] = 2;
}
function balanceOf(address owner) public view virtual returns (uint256) {
return _balances[owner];
}
function ownerOf(uint256 tokenId) public view virtual returns (address) {
address owner = _owners[tokenId];
return owner;
}
mapping(uint256 => address) private _owners;
mapping(address => uint256) private _balances;
}
contract RevertingContract {
constructor() {
revert();
}
}
contract MockContractWithConstructorArgs {
uint256 public immutable x;
bool public y;
bytes20 public z;
constructor(uint256 _x, bool _y, bytes20 _z) payable {
x = _x;
y = _y;
z = _z;
}
}
contract MockContractPayable {
receive() external payable {}
}

38
packages/contracts/lib/forge-std/test/StdConstants.t.sol Normal file
View file

@ -0,0 +1,38 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {StdConstants} from "../src/StdConstants.sol";
import {Test} from "../src/Test.sol";
contract StdConstantsTest is Test {
function testVm() public view {
assertEq(StdConstants.VM.getBlockNumber(), 1);
}
function testVmDerivation() public pure {
assertEq(address(StdConstants.VM), address(uint160(uint256(keccak256("hevm cheat code")))));
}
function testConsoleDerivation() public pure {
assertEq(StdConstants.CONSOLE, address(uint160(uint88(bytes11("console.log")))));
}
function testDefaultSender() public view {
assertEq(StdConstants.DEFAULT_SENDER, msg.sender);
}
function testDefaultSenderDerivation() public pure {
assertEq(StdConstants.DEFAULT_SENDER, address(uint160(uint256(keccak256("foundry default caller")))));
}
function testDefaultTestContract() public {
assertEq(StdConstants.DEFAULT_TEST_CONTRACT, address(new Dummy()));
}
function testDefaultTestContractDerivation() public view {
assertEq(address(this), StdConstants.VM.computeCreateAddress(StdConstants.DEFAULT_SENDER, 1));
assertEq(StdConstants.DEFAULT_TEST_CONTRACT, StdConstants.VM.computeCreateAddress(address(this), 1));
}
}
contract Dummy {}

119
packages/contracts/lib/forge-std/test/StdError.t.sol Normal file
View file

@ -0,0 +1,119 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {stdError} from "../src/StdError.sol";
import {Test} from "../src/Test.sol";
contract StdErrorsTest is Test {
ErrorsTest test;
function setUp() public {
test = new ErrorsTest();
}
function test_RevertIf_AssertionError() public {
vm.expectRevert(stdError.assertionError);
test.assertionError();
}
function test_RevertIf_ArithmeticError() public {
vm.expectRevert(stdError.arithmeticError);
test.arithmeticError(10);
}
function test_RevertIf_DivisionError() public {
vm.expectRevert(stdError.divisionError);
test.divError(0);
}
function test_RevertIf_ModError() public {
vm.expectRevert(stdError.divisionError);
test.modError(0);
}
function test_RevertIf_EnumConversionError() public {
vm.expectRevert(stdError.enumConversionError);
test.enumConversion(1);
}
function test_RevertIf_EncodeStgError() public {
vm.expectRevert(stdError.encodeStorageError);
test.encodeStgError();
}
function test_RevertIf_PopError() public {
vm.expectRevert(stdError.popError);
test.pop();
}
function test_RevertIf_IndexOOBError() public {
vm.expectRevert(stdError.indexOOBError);
test.indexOOBError(1);
}
function test_RevertIf_MemOverflowError() public {
vm.expectRevert(stdError.memOverflowError);
test.mem();
}
function test_RevertIf_InternError() public {
vm.expectRevert(stdError.zeroVarError);
test.intern();
}
}
contract ErrorsTest {
enum T {
T1
}
uint256[] public someArr;
bytes someBytes;
function assertionError() public pure {
assert(false);
}
function arithmeticError(uint256 a) public pure {
a -= 100;
}
function divError(uint256 a) public pure {
100 / a;
}
function modError(uint256 a) public pure {
100 % a;
}
function enumConversion(uint256 a) public pure {
T(a);
}
function encodeStgError() public {
assembly ("memory-safe") {
sstore(someBytes.slot, 1)
}
keccak256(someBytes);
}
function pop() public {
someArr.pop();
}
function indexOOBError(uint256 a) public pure {
uint256[] memory t = new uint256[](0);
t[a];
}
function mem() public pure {
uint256 l = 2 ** 256 / 32;
new uint256[](l);
}
function intern() public returns (uint256) {
function(uint256) internal returns (uint256) x;
x(2);
return 7;
}
}

49
packages/contracts/lib/forge-std/test/StdJson.t.sol Normal file
View file

@ -0,0 +1,49 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test, stdJson} from "../src/Test.sol";
contract StdJsonTest is Test {
using stdJson for string;
string root;
string path;
function setUp() public {
root = vm.projectRoot();
path = string.concat(root, "/test/fixtures/test.json");
}
struct SimpleJson {
uint256 a;
string b;
}
struct NestedJson {
uint256 a;
string b;
SimpleJson c;
}
function test_readJson() public view {
string memory json = vm.readFile(path);
assertEq(json.readUint(".a"), 123);
}
function test_writeJson() public {
string memory json = "json";
json.serialize("a", uint256(123));
string memory semiFinal = json.serialize("b", string("test"));
string memory finalJson = json.serialize("c", semiFinal);
finalJson.write(path);
string memory json_ = vm.readFile(path);
bytes memory data = json_.parseRaw("$");
NestedJson memory decodedData = abi.decode(data, (NestedJson));
assertEq(decodedData.a, 123);
assertEq(decodedData.b, "test");
assertEq(decodedData.c.a, 123);
assertEq(decodedData.c.b, "test");
}
}

202
packages/contracts/lib/forge-std/test/StdMath.t.sol Normal file
View file

@ -0,0 +1,202 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {stdMath} from "../src/StdMath.sol";
import {Test, stdError} from "../src/Test.sol";
contract StdMathMock is Test {
function exposedPercentDelta(uint256 a, uint256 b) public pure returns (uint256) {
return stdMath.percentDelta(a, b);
}
function exposedPercentDelta(int256 a, int256 b) public pure returns (uint256) {
return stdMath.percentDelta(a, b);
}
}
contract StdMathTest is Test {
function test_GetAbs() external pure {
assertEq(stdMath.abs(-50), 50);
assertEq(stdMath.abs(50), 50);
assertEq(stdMath.abs(-1337), 1337);
assertEq(stdMath.abs(0), 0);
assertEq(stdMath.abs(type(int256).min), (type(uint256).max >> 1) + 1);
assertEq(stdMath.abs(type(int256).max), (type(uint256).max >> 1));
}
function testFuzz_GetAbs(int256 a) external pure {
uint256 manualAbs = getAbs(a);
uint256 abs = stdMath.abs(a);
assertEq(abs, manualAbs);
}
function test_GetDelta_Uint() external pure {
assertEq(stdMath.delta(uint256(0), uint256(0)), 0);
assertEq(stdMath.delta(uint256(0), uint256(1337)), 1337);
assertEq(stdMath.delta(uint256(0), type(uint64).max), type(uint64).max);
assertEq(stdMath.delta(uint256(0), type(uint128).max), type(uint128).max);
assertEq(stdMath.delta(uint256(0), type(uint256).max), type(uint256).max);
assertEq(stdMath.delta(0, uint256(0)), 0);
assertEq(stdMath.delta(1337, uint256(0)), 1337);
assertEq(stdMath.delta(type(uint64).max, uint256(0)), type(uint64).max);
assertEq(stdMath.delta(type(uint128).max, uint256(0)), type(uint128).max);
assertEq(stdMath.delta(type(uint256).max, uint256(0)), type(uint256).max);
assertEq(stdMath.delta(1337, uint256(1337)), 0);
assertEq(stdMath.delta(type(uint256).max, type(uint256).max), 0);
assertEq(stdMath.delta(5000, uint256(1250)), 3750);
}
function testFuzz_GetDelta_Uint(uint256 a, uint256 b) external pure {
uint256 manualDelta = a > b ? a - b : b - a;
uint256 delta = stdMath.delta(a, b);
assertEq(delta, manualDelta);
}
function test_GetDelta_Int() external pure {
assertEq(stdMath.delta(int256(0), int256(0)), 0);
assertEq(stdMath.delta(int256(0), int256(1337)), 1337);
assertEq(stdMath.delta(int256(0), type(int64).max), type(uint64).max >> 1);
assertEq(stdMath.delta(int256(0), type(int128).max), type(uint128).max >> 1);
assertEq(stdMath.delta(int256(0), type(int256).max), type(uint256).max >> 1);
assertEq(stdMath.delta(0, int256(0)), 0);
assertEq(stdMath.delta(1337, int256(0)), 1337);
assertEq(stdMath.delta(type(int64).max, int256(0)), type(uint64).max >> 1);
assertEq(stdMath.delta(type(int128).max, int256(0)), type(uint128).max >> 1);
assertEq(stdMath.delta(type(int256).max, int256(0)), type(uint256).max >> 1);
assertEq(stdMath.delta(-0, int256(0)), 0);
assertEq(stdMath.delta(-1337, int256(0)), 1337);
assertEq(stdMath.delta(type(int64).min, int256(0)), (type(uint64).max >> 1) + 1);
assertEq(stdMath.delta(type(int128).min, int256(0)), (type(uint128).max >> 1) + 1);
assertEq(stdMath.delta(type(int256).min, int256(0)), (type(uint256).max >> 1) + 1);
assertEq(stdMath.delta(int256(0), -0), 0);
assertEq(stdMath.delta(int256(0), -1337), 1337);
assertEq(stdMath.delta(int256(0), type(int64).min), (type(uint64).max >> 1) + 1);
assertEq(stdMath.delta(int256(0), type(int128).min), (type(uint128).max >> 1) + 1);
assertEq(stdMath.delta(int256(0), type(int256).min), (type(uint256).max >> 1) + 1);
assertEq(stdMath.delta(1337, int256(1337)), 0);
assertEq(stdMath.delta(type(int256).max, type(int256).max), 0);
assertEq(stdMath.delta(type(int256).min, type(int256).min), 0);
assertEq(stdMath.delta(type(int256).min, type(int256).max), type(uint256).max);
assertEq(stdMath.delta(5000, int256(1250)), 3750);
}
function testFuzz_GetDelta_Int(int256 a, int256 b) external pure {
uint256 absA = getAbs(a);
uint256 absB = getAbs(b);
uint256 absDelta = absA > absB ? absA - absB : absB - absA;
uint256 manualDelta;
if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) {
manualDelta = absDelta;
}
// (a < 0 && b >= 0) || (a >= 0 && b < 0)
else {
manualDelta = absA + absB;
}
uint256 delta = stdMath.delta(a, b);
assertEq(delta, manualDelta);
}
function test_GetPercentDelta_Uint() external {
StdMathMock stdMathMock = new StdMathMock();
assertEq(stdMath.percentDelta(uint256(0), uint256(1337)), 1e18);
assertEq(stdMath.percentDelta(uint256(0), type(uint64).max), 1e18);
assertEq(stdMath.percentDelta(uint256(0), type(uint128).max), 1e18);
assertEq(stdMath.percentDelta(uint256(0), type(uint192).max), 1e18);
assertEq(stdMath.percentDelta(1337, uint256(1337)), 0);
assertEq(stdMath.percentDelta(type(uint192).max, type(uint192).max), 0);
assertEq(stdMath.percentDelta(0, uint256(2500)), 1e18);
assertEq(stdMath.percentDelta(2500, uint256(2500)), 0);
assertEq(stdMath.percentDelta(5000, uint256(2500)), 1e18);
assertEq(stdMath.percentDelta(7500, uint256(2500)), 2e18);
vm.expectRevert("stdMath percentDelta(uint256,uint256): Divisor is zero");
stdMathMock.exposedPercentDelta(uint256(1), 0);
}
function testFuzz_GetPercentDelta_Uint(uint192 a, uint192 b) external pure {
vm.assume(b != 0);
uint256 manualDelta = a > b ? a - b : b - a;
uint256 manualPercentDelta = manualDelta * 1e18 / b;
uint256 percentDelta = stdMath.percentDelta(a, b);
assertEq(percentDelta, manualPercentDelta);
}
function test_GetPercentDelta_Int() external {
// We deploy a mock version so we can properly test the revert.
StdMathMock stdMathMock = new StdMathMock();
assertEq(stdMath.percentDelta(int256(0), int256(1337)), 1e18);
assertEq(stdMath.percentDelta(int256(0), -1337), 1e18);
assertEq(stdMath.percentDelta(int256(0), type(int64).min), 1e18);
assertEq(stdMath.percentDelta(int256(0), type(int128).min), 1e18);
assertEq(stdMath.percentDelta(int256(0), type(int192).min), 1e18);
assertEq(stdMath.percentDelta(int256(0), type(int64).max), 1e18);
assertEq(stdMath.percentDelta(int256(0), type(int128).max), 1e18);
assertEq(stdMath.percentDelta(int256(0), type(int192).max), 1e18);
assertEq(stdMath.percentDelta(1337, int256(1337)), 0);
assertEq(stdMath.percentDelta(type(int192).max, type(int192).max), 0);
assertEq(stdMath.percentDelta(type(int192).min, type(int192).min), 0);
assertEq(stdMath.percentDelta(type(int192).min, type(int192).max), 2e18); // rounds the 1 wei diff down
assertEq(stdMath.percentDelta(type(int192).max, type(int192).min), 2e18 - 1); // rounds the 1 wei diff down
assertEq(stdMath.percentDelta(0, int256(2500)), 1e18);
assertEq(stdMath.percentDelta(2500, int256(2500)), 0);
assertEq(stdMath.percentDelta(5000, int256(2500)), 1e18);
assertEq(stdMath.percentDelta(7500, int256(2500)), 2e18);
vm.expectRevert("stdMath percentDelta(int256,int256): Divisor is zero");
stdMathMock.exposedPercentDelta(int256(1), 0);
}
function testFuzz_GetPercentDelta_Int(int192 a, int192 b) external pure {
vm.assume(b != 0);
uint256 absA = getAbs(a);
uint256 absB = getAbs(b);
uint256 absDelta = absA > absB ? absA - absB : absB - absA;
uint256 manualDelta;
if ((a >= 0 && b >= 0) || (a < 0 && b < 0)) {
manualDelta = absDelta;
}
// (a < 0 && b >= 0) || (a >= 0 && b < 0)
else {
manualDelta = absA + absB;
}
uint256 manualPercentDelta = manualDelta * 1e18 / absB;
uint256 percentDelta = stdMath.percentDelta(a, b);
assertEq(percentDelta, manualPercentDelta);
}
/*//////////////////////////////////////////////////////////////////////////
HELPERS
//////////////////////////////////////////////////////////////////////////*/
function getAbs(int256 a) private pure returns (uint256) {
if (a < 0) {
return a == type(int256).min ? uint256(type(int256).max) + 1 : uint256(-a);
}
return uint256(a);
}
}

532
packages/contracts/lib/forge-std/test/StdStorage.t.sol Normal file
View file

@ -0,0 +1,532 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {stdStorage, StdStorage} from "../src/StdStorage.sol";
import {Test} from "../src/Test.sol";
contract StdStorageTest is Test {
using stdStorage for StdStorage;
StorageTest internal test;
function setUp() public {
test = new StorageTest();
}
function test_StorageHidden() public {
assertEq(uint256(keccak256("my.random.var")), stdstore.target(address(test)).sig("hidden()").find());
}
function test_StorageObvious() public {
assertEq(uint256(0), stdstore.target(address(test)).sig("exists()").find());
}
function test_StorageExtraSload() public {
assertEq(16, stdstore.target(address(test)).sig(test.extra_sload.selector).find());
}
function test_StorageCheckedWriteHidden() public {
stdstore.target(address(test)).sig(test.hidden.selector).checked_write(100);
assertEq(uint256(test.hidden()), 100);
}
function test_StorageCheckedWriteObvious() public {
stdstore.target(address(test)).sig(test.exists.selector).checked_write(100);
assertEq(test.exists(), 100);
}
function test_StorageCheckedWriteSignedIntegerHidden() public {
stdstore.target(address(test)).sig(test.hidden.selector).checked_write_int(-100);
assertEq(int256(uint256(test.hidden())), -100);
}
function test_StorageCheckedWriteSignedIntegerObvious() public {
stdstore.target(address(test)).sig(test.tG.selector).checked_write_int(-100);
assertEq(test.tG(), -100);
}
function test_StorageMapStructA() public {
uint256 slot =
stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(0).find();
assertEq(uint256(keccak256(abi.encode(address(this), 4))), slot);
}
function test_StorageMapStructB() public {
uint256 slot =
stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(1).find();
assertEq(uint256(keccak256(abi.encode(address(this), 4))) + 1, slot);
}
function test_StorageDeepMap() public {
uint256 slot = stdstore.target(address(test)).sig(test.deep_map.selector).with_key(address(this))
.with_key(address(this)).find();
assertEq(uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint256(5)))))), slot);
}
function test_StorageCheckedWriteDeepMap() public {
stdstore.target(address(test)).sig(test.deep_map.selector).with_key(address(this)).with_key(address(this))
.checked_write(100);
assertEq(100, test.deep_map(address(this), address(this)));
}
function test_StorageDeepMapStructA() public {
uint256 slot = stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this))
.with_key(address(this)).depth(0).find();
assertEq(
bytes32(
uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint256(6)))))) + 0
),
bytes32(slot)
);
}
function test_StorageDeepMapStructB() public {
uint256 slot = stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this))
.with_key(address(this)).depth(1).find();
assertEq(
bytes32(
uint256(keccak256(abi.encode(address(this), keccak256(abi.encode(address(this), uint256(6)))))) + 1
),
bytes32(slot)
);
}
function test_StorageCheckedWriteDeepMapStructA() public {
stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this))
.with_key(address(this)).depth(0).checked_write(100);
(uint256 a, uint256 b) = test.deep_map_struct(address(this), address(this));
assertEq(100, a);
assertEq(0, b);
}
function test_StorageCheckedWriteDeepMapStructB() public {
stdstore.target(address(test)).sig(test.deep_map_struct.selector).with_key(address(this))
.with_key(address(this)).depth(1).checked_write(100);
(uint256 a, uint256 b) = test.deep_map_struct(address(this), address(this));
assertEq(0, a);
assertEq(100, b);
}
function test_StorageCheckedWriteMapStructA() public {
stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(0).checked_write(100);
(uint256 a, uint256 b) = test.map_struct(address(this));
assertEq(a, 100);
assertEq(b, 0);
}
function test_StorageCheckedWriteMapStructB() public {
stdstore.target(address(test)).sig(test.map_struct.selector).with_key(address(this)).depth(1).checked_write(100);
(uint256 a, uint256 b) = test.map_struct(address(this));
assertEq(a, 0);
assertEq(b, 100);
}
function test_StorageStructA() public {
uint256 slot = stdstore.target(address(test)).sig(test.basic.selector).depth(0).find();
assertEq(uint256(7), slot);
}
function test_StorageStructB() public {
uint256 slot = stdstore.target(address(test)).sig(test.basic.selector).depth(1).find();
assertEq(uint256(7) + 1, slot);
}
function test_StorageCheckedWriteStructA() public {
stdstore.target(address(test)).sig(test.basic.selector).depth(0).checked_write(100);
(uint256 a, uint256 b) = test.basic();
assertEq(a, 100);
assertEq(b, 1337);
}
function test_StorageCheckedWriteStructB() public {
stdstore.target(address(test)).sig(test.basic.selector).depth(1).checked_write(100);
(uint256 a, uint256 b) = test.basic();
assertEq(a, 1337);
assertEq(b, 100);
}
function test_StorageMapAddrFound() public {
uint256 slot = stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).find();
assertEq(uint256(keccak256(abi.encode(address(this), uint256(1)))), slot);
}
function test_StorageMapAddrRoot() public {
(uint256 slot, bytes32 key) =
stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).parent();
assertEq(address(uint160(uint256(key))), address(this));
assertEq(uint256(1), slot);
slot = stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).root();
assertEq(uint256(1), slot);
}
function test_StorageMapUintFound() public {
uint256 slot = stdstore.target(address(test)).sig(test.map_uint.selector).with_key(100).find();
assertEq(uint256(keccak256(abi.encode(100, uint256(2)))), slot);
}
function test_StorageCheckedWriteMapUint() public {
stdstore.target(address(test)).sig(test.map_uint.selector).with_key(100).checked_write(100);
assertEq(100, test.map_uint(100));
}
function test_StorageCheckedWriteMapAddr() public {
stdstore.target(address(test)).sig(test.map_addr.selector).with_key(address(this)).checked_write(100);
assertEq(100, test.map_addr(address(this)));
}
function test_StorageCheckedWriteMapBool() public {
stdstore.target(address(test)).sig(test.map_bool.selector).with_key(address(this)).checked_write(true);
assertTrue(test.map_bool(address(this)));
}
function testFuzz_StorageCheckedWriteMapPacked(address addr, uint128 value) public {
stdstore.enable_packed_slots().target(address(test)).sig(test.read_struct_lower.selector).with_key(addr)
.checked_write(value);
assertEq(test.read_struct_lower(addr), value);
stdstore.enable_packed_slots().target(address(test)).sig(test.read_struct_upper.selector).with_key(addr)
.checked_write(value);
assertEq(test.read_struct_upper(addr), value);
}
function test_StorageCheckedWriteMapPackedFullSuccess() public {
uint256 full = test.map_packed(address(1337));
// keep upper 128, set lower 128 to 1337
full = (full & (uint256((1 << 128) - 1) << 128)) | 1337;
stdstore.target(address(test)).sig(test.map_packed.selector).with_key(address(uint160(1337)))
.checked_write(full);
assertEq(1337, test.read_struct_lower(address(1337)));
}
function test_RevertStorageConst() public {
StorageTestTarget target = new StorageTestTarget(test);
vm.expectRevert("stdStorage find(StdStorage): No storage use detected for target.");
target.expectRevertStorageConst();
}
function testFuzz_StorageNativePack(uint248 val1, uint248 val2, bool boolVal1, bool boolVal2) public {
stdstore.enable_packed_slots().target(address(test)).sig(test.tA.selector).checked_write(val1);
stdstore.enable_packed_slots().target(address(test)).sig(test.tB.selector).checked_write(boolVal1);
stdstore.enable_packed_slots().target(address(test)).sig(test.tC.selector).checked_write(boolVal2);
stdstore.enable_packed_slots().target(address(test)).sig(test.tD.selector).checked_write(val2);
assertEq(test.tA(), val1);
assertEq(test.tB(), boolVal1);
assertEq(test.tC(), boolVal2);
assertEq(test.tD(), val2);
}
function test_StorageReadBytes32() public {
bytes32 val = stdstore.target(address(test)).sig(test.tE.selector).read_bytes32();
assertEq(val, hex"1337");
}
function test_StorageReadBool_False() public {
bool val = stdstore.target(address(test)).sig(test.tB.selector).read_bool();
assertEq(val, false);
}
function test_StorageReadBool_True() public {
bool val = stdstore.target(address(test)).sig(test.tH.selector).read_bool();
assertEq(val, true);
}
function test_RevertIf_ReadingNonBoolValue() public {
vm.expectRevert("stdStorage read_bool(StdStorage): Cannot decode. Make sure you are reading a bool.");
this.readNonBoolValue();
}
function readNonBoolValue() public {
stdstore.target(address(test)).sig(test.tE.selector).read_bool();
}
function test_StorageReadAddress() public {
address val = stdstore.target(address(test)).sig(test.tF.selector).read_address();
assertEq(val, address(1337));
}
function test_StorageReadUint() public {
uint256 val = stdstore.target(address(test)).sig(test.exists.selector).read_uint();
assertEq(val, 1);
}
function test_StorageReadInt() public {
int256 val = stdstore.target(address(test)).sig(test.tG.selector).read_int();
assertEq(val, type(int256).min);
}
function testFuzz_Packed(uint256 val, uint8 elemToGet) public {
// This function tries an assortment of packed slots, shifts meaning number of elements
// that are packed. Shiftsizes are the size of each element, i.e. 8 means a data type that is 8 bits, 16 == 16 bits, etc.
// Combined, these determine how a slot is packed. Making it random is too hard to avoid global rejection limit
// and make it performant.
// change the number of shifts
for (uint256 i = 1; i < 5; i++) {
uint256 shifts = i;
elemToGet = uint8(bound(elemToGet, 0, shifts - 1));
uint256[] memory shiftSizes = new uint256[](shifts);
for (uint256 j; j < shifts; j++) {
shiftSizes[j] = 8 * (j + 1);
}
test.setRandomPacking(val);
uint256 leftBits;
uint256 rightBits;
for (uint256 j; j < shiftSizes.length; j++) {
if (j < elemToGet) {
leftBits += shiftSizes[j];
} else if (elemToGet != j) {
rightBits += shiftSizes[j];
}
}
// we may have some right bits unaccounted for
leftBits += 256 - (leftBits + shiftSizes[elemToGet] + rightBits);
// clear left bits, then clear right bits and realign
uint256 expectedValToRead = (val << leftBits) >> (leftBits + rightBits);
uint256 readVal = stdstore.target(address(test)).enable_packed_slots()
.sig("getRandomPacked(uint8,uint8[],uint8)").with_calldata(abi.encode(shifts, shiftSizes, elemToGet))
.read_uint();
assertEq(readVal, expectedValToRead);
}
}
function testFuzz_Packed2(uint256 nvars, uint256 seed) public {
// Number of random variables to generate.
nvars = bound(nvars, 1, 20);
// This will decrease as we generate values in the below loop.
uint256 bitsRemaining = 256;
// Generate a random value and size for each variable.
uint256[] memory vals = new uint256[](nvars);
uint256[] memory sizes = new uint256[](nvars);
uint256[] memory offsets = new uint256[](nvars);
for (uint256 i = 0; i < nvars; i++) {
// Generate a random value and size.
offsets[i] = i == 0 ? 0 : offsets[i - 1] + sizes[i - 1];
uint256 nvarsRemaining = nvars - i;
uint256 maxVarSize = bitsRemaining - nvarsRemaining + 1;
sizes[i] = bound(uint256(keccak256(abi.encodePacked(seed, i + 256))), 1, maxVarSize);
bitsRemaining -= sizes[i];
uint256 maxVal;
uint256 varSize = sizes[i];
assembly {
// mask = (1 << varSize) - 1
maxVal := sub(shl(varSize, 1), 1)
}
vals[i] = bound(uint256(keccak256(abi.encodePacked(seed, i))), 0, maxVal);
}
// Pack all values into the slot.
for (uint256 i = 0; i < nvars; i++) {
stdstore.enable_packed_slots().target(address(test)).sig("getRandomPacked(uint256,uint256)")
.with_key(sizes[i]).with_key(offsets[i]).checked_write(vals[i]);
}
// Verify the read data matches.
for (uint256 i = 0; i < nvars; i++) {
uint256 readVal = stdstore.enable_packed_slots().target(address(test))
.sig("getRandomPacked(uint256,uint256)").with_key(sizes[i]).with_key(offsets[i]).read_uint();
uint256 retVal = test.getRandomPacked(sizes[i], offsets[i]);
assertEq(readVal, vals[i]);
assertEq(retVal, vals[i]);
}
}
function testEdgeCaseArray() public {
stdstore.target(address(test)).sig("edgeCaseArray(uint256)").with_key(uint256(0)).checked_write(1);
assertEq(test.edgeCaseArray(0), 1);
}
// Regression test for https://github.com/foundry-rs/forge-std/issues/740
// `find()` used to infinite-loop on tokens whose `balanceOf` reads multiple
// storage slots and returns a derived value (reflection tokens).
function test_RevertFindOnReflectionToken() public {
MockReflectionToken token = new MockReflectionToken();
ReflectionTokenTarget target = new ReflectionTokenTarget(token);
vm.expectRevert("stdStorage find(StdStorage): Slot(s) not found.");
target.findBalanceOf(address(this));
}
}
contract StorageTestTarget {
using stdStorage for StdStorage;
StdStorage internal stdstore;
StorageTest internal test;
constructor(StorageTest test_) {
test = test_;
}
function expectRevertStorageConst() public {
stdstore.target(address(test)).sig("const()").find();
}
}
contract ReflectionTokenTarget {
using stdStorage for StdStorage;
StdStorage internal stdstore;
MockReflectionToken internal token;
constructor(MockReflectionToken token_) {
token = token_;
}
function findBalanceOf(address who) public {
stdstore.target(address(token)).sig("balanceOf(address)").with_key(who).find();
}
}
contract StorageTest {
uint256 public exists = 1;
mapping(address => uint256) public map_addr;
mapping(uint256 => uint256) public map_uint;
mapping(address => uint256) public map_packed;
mapping(address => UnpackedStruct) public map_struct;
mapping(address => mapping(address => uint256)) public deep_map;
mapping(address => mapping(address => UnpackedStruct)) public deep_map_struct;
UnpackedStruct public basic;
uint248 public tA;
bool public tB;
bool public tC = false;
uint248 public tD = 1;
struct UnpackedStruct {
uint256 a;
uint256 b;
}
mapping(address => bool) public map_bool;
bytes32 public tE = hex"1337";
address public tF = address(1337);
int256 public tG = type(int256).min;
bool public tH = true;
bytes32 private tI = ~bytes32(hex"1337");
uint256 randomPacking;
// Array with length matching values of elements.
uint256[] public edgeCaseArray = [3, 3, 3];
constructor() {
basic = UnpackedStruct({a: 1337, b: 1337});
uint256 two = (1 << 128) | 1;
map_packed[msg.sender] = two;
map_packed[address(uint160(1337))] = 1 << 128;
}
function read_struct_upper(address who) public view returns (uint256) {
return map_packed[who] >> 128;
}
function read_struct_lower(address who) public view returns (uint256) {
return map_packed[who] & ((1 << 128) - 1);
}
function hidden() public view returns (bytes32 t) {
bytes32 slot = keccak256("my.random.var");
assembly ("memory-safe") {
t := sload(slot)
}
}
function const() public pure returns (bytes32 t) {
t = bytes32(hex"1337");
}
function extra_sload() public view returns (bytes32 t) {
// trigger read on slot `tE`, and make a staticcall to make sure compiler doesn't optimize this SLOAD away
assembly {
pop(staticcall(gas(), sload(tE.slot), 0, 0, 0, 0))
}
t = tI;
}
function setRandomPacking(uint256 val) public {
randomPacking = val;
}
function _getMask(uint256 size) internal pure returns (uint256 mask) {
assembly {
// mask = (1 << size) - 1
mask := sub(shl(size, 1), 1)
}
}
function setRandomPacking(uint256 val, uint256 size, uint256 offset) public {
// Generate mask based on the size of the value
uint256 mask = _getMask(size);
// Zero out all bits for the word we're about to set
uint256 cleanedWord = randomPacking & ~(mask << offset);
// Place val in the correct spot of the cleaned word
randomPacking = cleanedWord | val << offset;
}
function getRandomPacked(uint256 size, uint256 offset) public view returns (uint256) {
// Generate mask based on the size of the value
uint256 mask = _getMask(size);
// Shift to place the bits in the correct position, and use mask to zero out remaining bits
return (randomPacking >> offset) & mask;
}
function getRandomPacked(uint8 shifts, uint8[] memory shiftSizes, uint8 elem) public view returns (uint256) {
require(elem < shifts, "!elem");
uint256 leftBits;
uint256 rightBits;
for (uint256 i; i < shiftSizes.length; i++) {
if (i < elem) {
leftBits += shiftSizes[i];
} else if (elem != i) {
rightBits += shiftSizes[i];
}
}
// we may have some right bits unaccounted for
leftBits += 256 - (leftBits + shiftSizes[elem] + rightBits);
// clear left bits, then clear right bits and realign
return (randomPacking << leftBits) >> (leftBits + rightBits);
}
}
// Minimal mock of a reflection token: `balanceOf` reads many storage slots
// and always returns a constant, so no single slot mutation can change its
// return value and stdStorage can never find a matching slot.
contract MockReflectionToken {
uint256 internal _a = 1;
uint256 internal _b = 2;
uint256 internal _c = 3;
mapping(address => uint256) internal _balances;
constructor() {
_balances[msg.sender] = 1000 ether;
}
// Reads _a, _b, _c, and _balances[account] but always returns a constant.
// This means mutating any single slot won't change the return value.
function balanceOf(address account) public view returns (uint256) {
uint256 x = _a + _b + _c + _balances[account];
x; // suppress unused warning
return 42;
}
}

110
packages/contracts/lib/forge-std/test/StdStyle.t.sol Normal file
View file

@ -0,0 +1,110 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test, console2, StdStyle} from "../src/Test.sol";
contract StdStyleTest is Test {
function test_StyleColor() public pure {
console2.log(StdStyle.red("StdStyle.red String Test"));
console2.log(StdStyle.red(uint256(10e18)));
console2.log(StdStyle.red(int256(-10e18)));
console2.log(StdStyle.red(true));
console2.log(StdStyle.red(address(0)));
console2.log(StdStyle.redBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.redBytes32("StdStyle.redBytes32"));
console2.log(StdStyle.green("StdStyle.green String Test"));
console2.log(StdStyle.green(uint256(10e18)));
console2.log(StdStyle.green(int256(-10e18)));
console2.log(StdStyle.green(true));
console2.log(StdStyle.green(address(0)));
console2.log(StdStyle.greenBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.greenBytes32("StdStyle.greenBytes32"));
console2.log(StdStyle.yellow("StdStyle.yellow String Test"));
console2.log(StdStyle.yellow(uint256(10e18)));
console2.log(StdStyle.yellow(int256(-10e18)));
console2.log(StdStyle.yellow(true));
console2.log(StdStyle.yellow(address(0)));
console2.log(StdStyle.yellowBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.yellowBytes32("StdStyle.yellowBytes32"));
console2.log(StdStyle.blue("StdStyle.blue String Test"));
console2.log(StdStyle.blue(uint256(10e18)));
console2.log(StdStyle.blue(int256(-10e18)));
console2.log(StdStyle.blue(true));
console2.log(StdStyle.blue(address(0)));
console2.log(StdStyle.blueBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.blueBytes32("StdStyle.blueBytes32"));
console2.log(StdStyle.magenta("StdStyle.magenta String Test"));
console2.log(StdStyle.magenta(uint256(10e18)));
console2.log(StdStyle.magenta(int256(-10e18)));
console2.log(StdStyle.magenta(true));
console2.log(StdStyle.magenta(address(0)));
console2.log(StdStyle.magentaBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.magentaBytes32("StdStyle.magentaBytes32"));
console2.log(StdStyle.cyan("StdStyle.cyan String Test"));
console2.log(StdStyle.cyan(uint256(10e18)));
console2.log(StdStyle.cyan(int256(-10e18)));
console2.log(StdStyle.cyan(true));
console2.log(StdStyle.cyan(address(0)));
console2.log(StdStyle.cyanBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.cyanBytes32("StdStyle.cyanBytes32"));
}
function test_StyleFontWeight() public pure {
console2.log(StdStyle.bold("StdStyle.bold String Test"));
console2.log(StdStyle.bold(uint256(10e18)));
console2.log(StdStyle.bold(int256(-10e18)));
console2.log(StdStyle.bold(address(0)));
console2.log(StdStyle.bold(true));
console2.log(StdStyle.boldBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.boldBytes32("StdStyle.boldBytes32"));
console2.log(StdStyle.dim("StdStyle.dim String Test"));
console2.log(StdStyle.dim(uint256(10e18)));
console2.log(StdStyle.dim(int256(-10e18)));
console2.log(StdStyle.dim(address(0)));
console2.log(StdStyle.dim(true));
console2.log(StdStyle.dimBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.dimBytes32("StdStyle.dimBytes32"));
console2.log(StdStyle.italic("StdStyle.italic String Test"));
console2.log(StdStyle.italic(uint256(10e18)));
console2.log(StdStyle.italic(int256(-10e18)));
console2.log(StdStyle.italic(address(0)));
console2.log(StdStyle.italic(true));
console2.log(StdStyle.italicBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.italicBytes32("StdStyle.italicBytes32"));
console2.log(StdStyle.underline("StdStyle.underline String Test"));
console2.log(StdStyle.underline(uint256(10e18)));
console2.log(StdStyle.underline(int256(-10e18)));
console2.log(StdStyle.underline(address(0)));
console2.log(StdStyle.underline(true));
console2.log(StdStyle.underlineBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.underlineBytes32("StdStyle.underlineBytes32"));
console2.log(StdStyle.inverse("StdStyle.inverse String Test"));
console2.log(StdStyle.inverse(uint256(10e18)));
console2.log(StdStyle.inverse(int256(-10e18)));
console2.log(StdStyle.inverse(address(0)));
console2.log(StdStyle.inverse(true));
console2.log(StdStyle.inverseBytes(hex"7109709ECfa91a80626fF3989D68f67F5b1DD12D"));
console2.log(StdStyle.inverseBytes32("StdStyle.inverseBytes32"));
}
function test_StyleCombined() public pure {
console2.log(StdStyle.red(StdStyle.bold("Red Bold String Test")));
console2.log(StdStyle.green(StdStyle.dim(uint256(10e18))));
console2.log(StdStyle.yellow(StdStyle.italic(int256(-10e18))));
console2.log(StdStyle.blue(StdStyle.underline(address(0))));
console2.log(StdStyle.magenta(StdStyle.inverse(true)));
}
function test_StyleCustom() public pure {
console2.log(h1("Custom Style 1"));
console2.log(h2("Custom Style 2"));
}
function h1(string memory a) private pure returns (string memory) {
return StdStyle.cyan(StdStyle.inverse(StdStyle.bold(a)));
}
function h2(string memory a) private pure returns (string memory) {
return StdStyle.magenta(StdStyle.bold(StdStyle.underline(a)));
}
}

49
packages/contracts/lib/forge-std/test/StdToml.t.sol Normal file
View file

@ -0,0 +1,49 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test, stdToml} from "../src/Test.sol";
contract StdTomlTest is Test {
using stdToml for string;
string root;
string path;
function setUp() public {
root = vm.projectRoot();
path = string.concat(root, "/test/fixtures/test.toml");
}
struct SimpleToml {
uint256 a;
string b;
}
struct NestedToml {
uint256 a;
string b;
SimpleToml c;
}
function test_readToml() public view {
string memory json = vm.readFile(path);
assertEq(json.readUint(".a"), 123);
}
function test_writeToml() public {
string memory json = "json";
json.serialize("a", uint256(123));
string memory semiFinal = json.serialize("b", string("test"));
string memory finalJson = json.serialize("c", semiFinal);
finalJson.write(path);
string memory toml = vm.readFile(path);
bytes memory data = toml.parseRaw("$");
NestedToml memory decodedData = abi.decode(data, (NestedToml));
assertEq(decodedData.a, 123);
assertEq(decodedData.b, "test");
assertEq(decodedData.c.a, 123);
assertEq(decodedData.c.b, "test");
}
}

342
packages/contracts/lib/forge-std/test/StdUtils.t.sol Normal file
View file

@ -0,0 +1,342 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test, StdUtils} from "../src/Test.sol";
contract StdUtilsMock is StdUtils {
// We deploy a mock version so we can properly test expected reverts.
function exposedGetTokenBalances(address token, address[] memory addresses)
external
returns (uint256[] memory balances)
{
return getTokenBalances(token, addresses);
}
function exposedBound(int256 num, int256 min, int256 max) external pure returns (int256) {
return bound(num, min, max);
}
function exposedBound(uint256 num, uint256 min, uint256 max) external pure returns (uint256) {
return bound(num, min, max);
}
function exposedBytesToUint(bytes memory b) external pure returns (uint256) {
return bytesToUint(b);
}
}
contract StdUtilsTest is Test {
/*//////////////////////////////////////////////////////////////////////////
BOUND UINT
//////////////////////////////////////////////////////////////////////////*/
function test_Bound() public pure {
assertEq(bound(uint256(5), 0, 4), 0);
assertEq(bound(uint256(0), 69, 69), 69);
assertEq(bound(uint256(0), 68, 69), 68);
assertEq(bound(uint256(10), 150, 190), 174);
assertEq(bound(uint256(300), 2800, 3200), 3107);
assertEq(bound(uint256(9999), 1337, 6666), 4669);
}
function test_Bound_WithinRange() public pure {
assertEq(bound(uint256(51), 50, 150), 51);
assertEq(bound(uint256(51), 50, 150), bound(bound(uint256(51), 50, 150), 50, 150));
assertEq(bound(uint256(149), 50, 150), 149);
assertEq(bound(uint256(149), 50, 150), bound(bound(uint256(149), 50, 150), 50, 150));
}
function test_Bound_EdgeCoverage() public pure {
assertEq(bound(uint256(0), 50, 150), 50);
assertEq(bound(uint256(1), 50, 150), 51);
assertEq(bound(uint256(2), 50, 150), 52);
assertEq(bound(uint256(3), 50, 150), 53);
assertEq(bound(type(uint256).max, 50, 150), 150);
assertEq(bound(type(uint256).max - 1, 50, 150), 149);
assertEq(bound(type(uint256).max - 2, 50, 150), 148);
assertEq(bound(type(uint256).max - 3, 50, 150), 147);
}
function testFuzz_Bound_DistributionIsEven(uint256 min, uint256 size) public pure {
size = size % 100 + 1;
min = bound(min, UINT256_MAX / 2, UINT256_MAX / 2 + size);
uint256 max = min + size - 1;
uint256 result;
for (uint256 i = 1; i <= size * 4; ++i) {
// x > max
result = bound(max + i, min, max);
assertEq(result, min + (i - 1) % size);
// x < min
result = bound(min - i, min, max);
assertEq(result, max - (i - 1) % size);
}
}
function testFuzz_Bound(uint256 num, uint256 min, uint256 max) public pure {
if (min > max) (min, max) = (max, min);
uint256 result = bound(num, min, max);
assertGe(result, min);
assertLe(result, max);
assertEq(result, bound(result, min, max));
if (num >= min && num <= max) assertEq(result, num);
}
function test_BoundUint256Max() public pure {
assertEq(bound(0, type(uint256).max - 1, type(uint256).max), type(uint256).max - 1);
assertEq(bound(1, type(uint256).max - 1, type(uint256).max), type(uint256).max);
}
function test_RevertIf_BoundMaxLessThanMin() public {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
vm.expectRevert(bytes("StdUtils bound(uint256,uint256,uint256): Max is less than min."));
stdUtils.exposedBound(uint256(5), 100, 10);
}
function testFuzz_RevertIf_BoundMaxLessThanMin(uint256 num, uint256 min, uint256 max) public {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
vm.assume(min > max);
vm.expectRevert(bytes("StdUtils bound(uint256,uint256,uint256): Max is less than min."));
stdUtils.exposedBound(num, min, max);
}
/*//////////////////////////////////////////////////////////////////////////
BOUND INT
//////////////////////////////////////////////////////////////////////////*/
function test_BoundInt() public pure {
assertEq(bound(-3, 0, 4), 2);
assertEq(bound(0, -69, -69), -69);
assertEq(bound(0, -69, -68), -68);
assertEq(bound(-10, 150, 190), 154);
assertEq(bound(-300, 2800, 3200), 2908);
assertEq(bound(9999, -1337, 6666), 1995);
}
function test_BoundInt_WithinRange() public pure {
assertEq(bound(51, -50, 150), 51);
assertEq(bound(51, -50, 150), bound(bound(51, -50, 150), -50, 150));
assertEq(bound(149, -50, 150), 149);
assertEq(bound(149, -50, 150), bound(bound(149, -50, 150), -50, 150));
}
function test_BoundInt_EdgeCoverage() public pure {
assertEq(bound(type(int256).min, -50, 150), -50);
assertEq(bound(type(int256).min + 1, -50, 150), -49);
assertEq(bound(type(int256).min + 2, -50, 150), -48);
assertEq(bound(type(int256).min + 3, -50, 150), -47);
assertEq(bound(type(int256).min, 10, 150), 10);
assertEq(bound(type(int256).min + 1, 10, 150), 11);
assertEq(bound(type(int256).min + 2, 10, 150), 12);
assertEq(bound(type(int256).min + 3, 10, 150), 13);
assertEq(bound(type(int256).max, -50, 150), 150);
assertEq(bound(type(int256).max - 1, -50, 150), 149);
assertEq(bound(type(int256).max - 2, -50, 150), 148);
assertEq(bound(type(int256).max - 3, -50, 150), 147);
assertEq(bound(type(int256).max, -50, -10), -10);
assertEq(bound(type(int256).max - 1, -50, -10), -11);
assertEq(bound(type(int256).max - 2, -50, -10), -12);
assertEq(bound(type(int256).max - 3, -50, -10), -13);
}
function testFuzz_BoundInt_DistributionIsEven(int256 min, uint256 size) public pure {
size = size % 100 + 1;
min = bound(min, -int256(size / 2), int256(size - size / 2));
int256 max = min + int256(size) - 1;
int256 result;
for (uint256 i = 1; i <= size * 4; ++i) {
// x > max
result = bound(max + int256(i), min, max);
assertEq(result, min + int256((i - 1) % size));
// x < min
result = bound(min - int256(i), min, max);
assertEq(result, max - int256((i - 1) % size));
}
}
function testFuzz_BoundInt(int256 num, int256 min, int256 max) public pure {
if (min > max) (min, max) = (max, min);
int256 result = bound(num, min, max);
assertGe(result, min);
assertLe(result, max);
assertEq(result, bound(result, min, max));
if (num >= min && num <= max) assertEq(result, num);
}
function test_BoundIntInt256Max() public pure {
assertEq(bound(0, type(int256).max - 1, type(int256).max), type(int256).max - 1);
assertEq(bound(1, type(int256).max - 1, type(int256).max), type(int256).max);
}
function test_BoundIntInt256Min() public pure {
assertEq(bound(0, type(int256).min, type(int256).min + 1), type(int256).min);
assertEq(bound(1, type(int256).min, type(int256).min + 1), type(int256).min + 1);
}
function test_RevertIf_BoundIntMaxLessThanMin() public {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
vm.expectRevert(bytes("StdUtils bound(int256,int256,int256): Max is less than min."));
stdUtils.exposedBound(-5, 100, 10);
}
function testFuzz_RevertIf_BoundIntMaxLessThanMin(int256 num, int256 min, int256 max) public {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
vm.assume(min > max);
vm.expectRevert(bytes("StdUtils bound(int256,int256,int256): Max is less than min."));
stdUtils.exposedBound(num, min, max);
}
/*//////////////////////////////////////////////////////////////////////////
BOUND PRIVATE KEY
//////////////////////////////////////////////////////////////////////////*/
function test_BoundPrivateKey() public pure {
assertEq(boundPrivateKey(0), 1);
assertEq(boundPrivateKey(1), 1);
assertEq(boundPrivateKey(300), 300);
assertEq(boundPrivateKey(9999), 9999);
assertEq(boundPrivateKey(SECP256K1_ORDER - 1), SECP256K1_ORDER - 1);
assertEq(boundPrivateKey(SECP256K1_ORDER), 1);
assertEq(boundPrivateKey(SECP256K1_ORDER + 1), 2);
assertEq(boundPrivateKey(UINT256_MAX), UINT256_MAX & SECP256K1_ORDER - 1); // x&y is equivalent to x-x%y
}
/*//////////////////////////////////////////////////////////////////////////
BYTES TO UINT
//////////////////////////////////////////////////////////////////////////*/
function test_BytesToUint() external pure {
bytes memory maxUint = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
bytes memory two = hex"02";
bytes memory millionEther = hex"d3c21bcecceda1000000";
assertEq(bytesToUint(maxUint), type(uint256).max);
assertEq(bytesToUint(two), 2);
assertEq(bytesToUint(millionEther), 1_000_000 ether);
}
function test_RevertIf_BytesLengthExceeds32() external {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
bytes memory thirty3Bytes = hex"ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff";
vm.expectRevert("StdUtils bytesToUint(bytes): Bytes length exceeds 32.");
stdUtils.exposedBytesToUint(thirty3Bytes);
}
/*//////////////////////////////////////////////////////////////////////////
COMPUTE CREATE ADDRESS
//////////////////////////////////////////////////////////////////////////*/
function test_ComputeCreateAddress() external pure {
address deployer = 0x6C9FC64A53c1b71FB3f9Af64d1ae3A4931A5f4E9;
uint256 nonce = 14;
address createAddress = computeCreateAddress(deployer, nonce);
assertEq(createAddress, 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45);
}
/*//////////////////////////////////////////////////////////////////////////
COMPUTE CREATE2 ADDRESS
//////////////////////////////////////////////////////////////////////////*/
function test_ComputeCreate2Address() external pure {
bytes32 salt = bytes32(uint256(31415));
bytes32 initcodeHash = keccak256(abi.encode(0x6080));
address deployer = 0x6C9FC64A53c1b71FB3f9Af64d1ae3A4931A5f4E9;
address create2Address = computeCreate2Address(salt, initcodeHash, deployer);
assertEq(create2Address, 0xB147a5d25748fda14b463EB04B111027C290f4d3);
}
function test_ComputeCreate2AddressWithDefaultDeployer() external pure {
bytes32 salt = 0xc290c670fde54e5ef686f9132cbc8711e76a98f0333a438a92daa442c71403c0;
bytes32 initcodeHash = hashInitCode(hex"6080", "");
assertEq(initcodeHash, 0x1a578b7a4b0b5755db6d121b4118d4bc68fe170dca840c59bc922f14175a76b0);
address create2Address = computeCreate2Address(salt, initcodeHash);
assertEq(create2Address, 0xc0ffEe2198a06235aAbFffe5Db0CacF1717f5Ac6);
}
}
contract StdUtilsForkTest is Test {
/*//////////////////////////////////////////////////////////////////////////
GET TOKEN BALANCES
//////////////////////////////////////////////////////////////////////////*/
address internal SHIB = 0x95aD61b0a150d79219dCF64E1E6Cc01f0B64C4cE;
address internal SHIB_HOLDER_0 = 0x855F5981e831D83e6A4b4EBFCAdAa68D92333170;
address internal SHIB_HOLDER_1 = 0x8F509A90c2e47779cA408Fe00d7A72e359229AdA;
address internal SHIB_HOLDER_2 = 0x0e3bbc0D04fF62211F71f3e4C45d82ad76224385;
address internal USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address internal USDC_HOLDER_0 = 0xDa9CE944a37d218c3302F6B82a094844C6ECEb17;
address internal USDC_HOLDER_1 = 0x3e67F4721E6d1c41a015f645eFa37BEd854fcf52;
function setUp() public {
// All tests of the `getTokenBalances` method are fork tests using live contracts.
vm.createSelectFork({urlOrAlias: "mainnet", blockNumber: 16_428_900});
}
function test_RevertIf_CannotGetTokenBalances_NonTokenContract() external {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
// The UniswapV2Factory contract has neither a `balanceOf` function nor a fallback function,
// so the `balanceOf` call should revert.
address token = address(0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f);
address[] memory addresses = new address[](1);
addresses[0] = USDC_HOLDER_0;
vm.expectRevert("Multicall3: call failed");
stdUtils.exposedGetTokenBalances(token, addresses);
}
function test_RevertIf_CannotGetTokenBalances_EOA() external {
// We deploy a mock version so we can properly test the revert.
StdUtilsMock stdUtils = new StdUtilsMock();
address eoa = vm.addr({privateKey: 1});
address[] memory addresses = new address[](1);
addresses[0] = USDC_HOLDER_0;
vm.expectRevert("StdUtils getTokenBalances(address,address[]): Token address is not a contract.");
stdUtils.exposedGetTokenBalances(eoa, addresses);
}
function test_GetTokenBalances_Empty() external {
address[] memory addresses = new address[](0);
uint256[] memory balances = getTokenBalances(USDC, addresses);
assertEq(balances.length, 0);
}
function test_GetTokenBalances_USDC() external {
address[] memory addresses = new address[](2);
addresses[0] = USDC_HOLDER_0;
addresses[1] = USDC_HOLDER_1;
uint256[] memory balances = getTokenBalances(USDC, addresses);
assertEq(balances[0], 159_000_000_000_000);
assertEq(balances[1], 131_350_000_000_000);
}
function test_GetTokenBalances_SHIB() external {
address[] memory addresses = new address[](3);
addresses[0] = SHIB_HOLDER_0;
addresses[1] = SHIB_HOLDER_1;
addresses[2] = SHIB_HOLDER_2;
uint256[] memory balances = getTokenBalances(SHIB, addresses);
assertEq(balances[0], 3_323_256_285_484.42e18);
assertEq(balances[1], 1_271_702_771_149.99999928e18);
assertEq(balances[2], 606_357_106_247e18);
}
}

18
packages/contracts/lib/forge-std/test/Vm.t.sol Normal file
View file

@ -0,0 +1,18 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test} from "../src/Test.sol";
import {Vm, VmSafe} from "../src/Vm.sol";
// These tests ensure that functions are never accidentally removed from a Vm interface, or
// inadvertently moved between Vm and VmSafe. These tests must be updated each time a function is
// added to or removed from Vm or VmSafe.
contract VmTest is Test {
function test_VmInterfaceId() public pure {
assertEq(type(Vm).interfaceId, bytes4(0x23dda1ff), "Vm");
}
function test_VmSafeInterfaceId() public pure {
assertEq(type(VmSafe).interfaceId, bytes4(0xc784e709), "VmSafe");
}
}

8
packages/contracts/lib/forge-std/test/compilation/CompilationScript.sol Normal file
View file

@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Script} from "../../src/Script.sol";
// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing
// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207
contract CompilationScript is Script {}

8
packages/contracts/lib/forge-std/test/compilation/CompilationScriptBase.sol Normal file
View file

@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {ScriptBase} from "../../src/Script.sol";
// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing
// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207
contract CompilationScriptBase is ScriptBase {}

8
packages/contracts/lib/forge-std/test/compilation/CompilationTest.sol Normal file
View file

@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {Test} from "../../src/Test.sol";
// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing
// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207
contract CompilationTest is Test {}

8
packages/contracts/lib/forge-std/test/compilation/CompilationTestBase.sol Normal file
View file

@ -0,0 +1,8 @@
// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity >=0.8.13 <0.9.0;
import {TestBase} from "../../src/Test.sol";
// The purpose of this contract is to benchmark compilation time to avoid accidentally introducing
// a change that results in very long compilation times with via-ir. See https://github.com/foundry-rs/forge-std/issues/207
contract CompilationTestBase is TestBase {}

187
packages/contracts/lib/forge-std/test/fixtures/broadcast.log.json vendored Normal file
View file

@ -0,0 +1,187 @@
{
"transactions": [
{
"hash": "0xc6006863c267735a11476b7f15b15bc718e117e2da114a2be815dd651e1a509f",
"type": "CALL",
"contractName": "Test",
"contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"function": "multiple_arguments(uint256,address,uint256[]):(uint256)",
"arguments": ["1", "0000000000000000000000000000000000001337", "[3,4]"],
"tx": {
"type": "0x02",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"gas": "0x73b9",
"value": "0x0",
"data": "0x23e99187000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000013370000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000030000000000000000000000000000000000000000000000000000000000000004",
"nonce": "0x3",
"accessList": []
}
},
{
"hash": "0xedf2b38d8d896519a947a1acf720f859bb35c0c5ecb8dd7511995b67b9853298",
"type": "CALL",
"contractName": "Test",
"contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"function": "inc():(uint256)",
"arguments": [],
"tx": {
"type": "0x02",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"gas": "0xdcb2",
"value": "0x0",
"data": "0x371303c0",
"nonce": "0x4",
"accessList": []
}
},
{
"hash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c",
"type": "CALL",
"contractName": "Test",
"contractAddress": "0x7c6b4bbe207d642d98d5c537142d85209e585087",
"function": "t(uint256):(uint256)",
"arguments": ["1"],
"tx": {
"type": "0x02",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0x7c6b4bbe207d642d98d5c537142d85209e585087",
"gas": "0x8599",
"value": "0x0",
"data": "0xafe29f710000000000000000000000000000000000000000000000000000000000000001",
"nonce": "0x5",
"accessList": []
}
}
],
"receipts": [
{
"transactionHash": "0x481dc86e40bba90403c76f8e144aa9ff04c1da2164299d0298573835f0991181",
"transactionIndex": "0x0",
"blockHash": "0xef0730448490304e5403be0fa8f8ce64f118e9adcca60c07a2ae1ab921d748af",
"blockNumber": "0x1",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": null,
"cumulativeGasUsed": "0x13f3a",
"gasUsed": "0x13f3a",
"contractAddress": "0x5fbdb2315678afecb367f032d93f642f64180aa3",
"logs": [],
"status": "0x1",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"effectiveGasPrice": "0xee6b2800"
},
{
"transactionHash": "0x6a187183545b8a9e7f1790e847139379bf5622baff2cb43acf3f5c79470af782",
"transactionIndex": "0x0",
"blockHash": "0xf3acb96a90071640c2a8c067ae4e16aad87e634ea8d8bbbb5b352fba86ba0148",
"blockNumber": "0x2",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": null,
"cumulativeGasUsed": "0x45d80",
"gasUsed": "0x45d80",
"contractAddress": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"logs": [],
"status": "0x1",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"effectiveGasPrice": "0xee6b2800"
},
{
"transactionHash": "0x064ad173b4867bdef2fb60060bbdaf01735fbf10414541ea857772974e74ea9d",
"transactionIndex": "0x0",
"blockHash": "0x8373d02109d3ee06a0225f23da4c161c656ccc48fe0fcee931d325508ae73e58",
"blockNumber": "0x3",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0x4e59b44847b379578588920ca78fbf26c0b4956c",
"cumulativeGasUsed": "0x45feb",
"gasUsed": "0x45feb",
"contractAddress": null,
"logs": [],
"status": "0x1",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"effectiveGasPrice": "0xee6b2800"
},
{
"transactionHash": "0xc6006863c267735a11476b7f15b15bc718e117e2da114a2be815dd651e1a509f",
"transactionIndex": "0x0",
"blockHash": "0x16712fae5c0e18f75045f84363fb6b4d9a9fe25e660c4ce286833a533c97f629",
"blockNumber": "0x4",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"cumulativeGasUsed": "0x5905",
"gasUsed": "0x5905",
"contractAddress": null,
"logs": [],
"status": "0x1",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"effectiveGasPrice": "0xee6b2800"
},
{
"transactionHash": "0xedf2b38d8d896519a947a1acf720f859bb35c0c5ecb8dd7511995b67b9853298",
"transactionIndex": "0x0",
"blockHash": "0x156b88c3eb9a1244ba00a1834f3f70de735b39e3e59006dd03af4fe7d5480c11",
"blockNumber": "0x5",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0xe7f1725e7734ce288f8367e1bb143e90bb3f0512",
"cumulativeGasUsed": "0xa9c4",
"gasUsed": "0xa9c4",
"contractAddress": null,
"logs": [],
"status": "0x1",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"effectiveGasPrice": "0xee6b2800"
},
{
"transactionHash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c",
"transactionIndex": "0x0",
"blockHash": "0xcf61faca67dbb2c28952b0b8a379e53b1505ae0821e84779679390cb8571cadb",
"blockNumber": "0x6",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0x7c6b4bbe207d642d98d5c537142d85209e585087",
"cumulativeGasUsed": "0x66c5",
"gasUsed": "0x66c5",
"contractAddress": null,
"logs": [
{
"address": "0x7c6b4bbe207d642d98d5c537142d85209e585087",
"topics": [
"0x0b2e13ff20ac7b474198655583edf70dedd2c1dc980e329c4fbb2fc0748b796b"
],
"data": "0x000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000046865726500000000000000000000000000000000000000000000000000000000",
"blockHash": "0xcf61faca67dbb2c28952b0b8a379e53b1505ae0821e84779679390cb8571cadb",
"blockNumber": "0x6",
"transactionHash": "0xa57e8e3981a6c861442e46c9471bd19cb3e21f9a8a6c63a72e7b5c47c6675a7c",
"transactionIndex": "0x1",
"logIndex": "0x0",
"transactionLogIndex": "0x0",
"removed": false
}
],
"status": "0x1",
"logsBloom": "0x00000000000800000000000000000010000000000000000000000000000180000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000100",
"effectiveGasPrice": "0xee6b2800"
},
{
"transactionHash": "0x11fbb10230c168ca1e36a7e5c69a6dbcd04fd9e64ede39d10a83e36ee8065c16",
"transactionIndex": "0x0",
"blockHash": "0xf1e0ed2eda4e923626ec74621006ed50b3fc27580dc7b4cf68a07ca77420e29c",
"blockNumber": "0x7",
"from": "0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266",
"to": "0x0000000000000000000000000000000000001337",
"cumulativeGasUsed": "0x5208",
"gasUsed": "0x5208",
"contractAddress": null,
"logs": [],
"status": "0x1",
"logsBloom": "0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
"effectiveGasPrice": "0xee6b2800"
}
],
"libraries": [
"src/Broadcast.t.sol:F:0x5fbdb2315678afecb367f032d93f642f64180aa3"
],
"pending": [],
"path": "broadcast/Broadcast.t.sol/31337/run-latest.json",
"returns": {},
"timestamp": 1655140035
}

81
packages/contracts/lib/forge-std/test/fixtures/config.toml vendored Normal file
View file

@ -0,0 +1,81 @@
# ------------------------------------------------
# EXAMPLE DEPLOYMENT CONFIG
# ------------------------------------------------
# -- MAINNET -------------------------------------
[mainnet]
endpoint_url = "${MAINNET_RPC}"
[mainnet.bool]
is_live = true
bool_array = [true, false]
[mainnet.address]
weth = "${WETH_MAINNET}"
deps = [
"0x0000000000000000000000000000000000000000",
"0x1111111111111111111111111111111111111111",
]
[mainnet.uint]
number = 1234
number_array = [5678, 9999]
[mainnet.int]
signed_number = -1234
signed_number_array = [-5678, 9999]
[mainnet.bytes32]
word = "0x00000000000000000000000000000000000000000000000000000000000004d2" # 1234
word_array = [
"0x000000000000000000000000000000000000000000000000000000000000162e", # 5678
"0x000000000000000000000000000000000000000000000000000000000000270f", # 9999
]
[mainnet.bytes]
b = "0xabcd"
b_array = ["0xdead", "0xbeef"]
[mainnet.string]
str = "foo"
str_array = ["bar", "baz"]
# -- OPTIMISM ------------------------------------
[optimism]
endpoint_url = "${OPTIMISM_RPC}"
[optimism.bool]
is_live = false
bool_array = [false, true]
[optimism.address]
weth = "${WETH_OPTIMISM}"
deps = [
"0x2222222222222222222222222222222222222222",
"0x3333333333333333333333333333333333333333",
]
[optimism.uint]
number = 9999
number_array = [1234, 5678]
[optimism.int]
signed_number = 9999
signed_number_array = [-1234, -5678]
[optimism.bytes32]
word = "0x000000000000000000000000000000000000000000000000000000000000270f" # 9999
word_array = [
"0x00000000000000000000000000000000000000000000000000000000000004d2", # 1234
"0x000000000000000000000000000000000000000000000000000000000000162e", # 5678
]
[optimism.bytes]
b = "0xdcba"
b_array = ["0xc0ffee", "0xbabe"]
[optimism.string]
str = "alice"
str_array = ["bob", "charlie"]

8
packages/contracts/lib/forge-std/test/fixtures/test.json vendored Normal file
View file

@ -0,0 +1,8 @@
{
"a": 123,
"b": "test",
"c": {
"a": 123,
"b": "test"
}
}

6
packages/contracts/lib/forge-std/test/fixtures/test.toml vendored Normal file
View file

@ -0,0 +1,6 @@
a = 123
b = "test"
[c]
a = 123
b = "test"

5
packages/contracts/lib/openzeppelin-contracts/.changeset/beige-cows-unite.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`Array`: Reduce reliance on recursion to prevent stack overflow and support larger arrays.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/better-tires-pull.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`Memory`: Add a `isReserved(Slice)` function that checks if the memory occupied by the slice is reserved (i.e. before the free memory pointer).

5
packages/contracts/lib/openzeppelin-contracts/.changeset/blue-jars-lay.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`ERC1155Crosschain`: Added an ERC-1155 extension to embed an ERC-7786 based crosschain bridge directly in the token contract.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/bright-cooks-brush.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`RLP`: Perform a memory copy when decoding `bytes` objects containing a single byte instead of returning a reference to the input.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/chatty-dryers-joke.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`AccountERC7579Hooked`: Do not revert if hook checks fail during the hook module uninstallation.

12
packages/contracts/lib/openzeppelin-contracts/.changeset/config.json Normal file
View file

@ -0,0 +1,12 @@
{
"$schema": "https://unpkg.com/@changesets/config@2.3.0/schema.json",
"changelog": [
"@changesets/changelog-github",
{
"repo": "OpenZeppelin/openzeppelin-contracts"
}
],
"commit": false,
"access": "public",
"baseBranch": "master"
}

5
packages/contracts/lib/openzeppelin-contracts/.changeset/cool-clocks-tick.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`ERC6372Utils`: Add utility library for ERC-6372 clock mode validation, supporting block number and timestamp modes with consistency checks.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/curly-pandas-flow.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': patch
---
Add ERC-165 detection for the `IERC6909ContentURI`, `IERC6909TokenSupply` and `IERC6909Metadata` interfaces in the `ERC6909ContentURI`, `ERC6909TokenSupply` and `ERC6909Metadata` contracts respectively.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/dark-papers-call.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`PaymasterERC721Owner`: Extension of `Paymaster` that approves sponsoring of user operation based on ownership of an ERC-721 NFT.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/erc4337-drop-draft-prefix.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`ERC4337Utils`, `IERC4337`: Drop the `draft-` prefix from the file names now that ERC-4337 is finalized. Imports must be updated from `account/utils/draft-ERC4337Utils.sol` to `account/utils/ERC4337Utils.sol` and from `interfaces/draft-IERC4337.sol` to `interfaces/IERC4337.sol`.

6
packages/contracts/lib/openzeppelin-contracts/.changeset/few-baboons-switch.md Normal file
View file

@ -0,0 +1,6 @@
---
'openzeppelin-solidity': minor
---
[Deprecations]
`Checkpoints`, `DoubleEndedQueue`, `EnumerableMap` and `EnumerableSet`: Deprecate the `at` function for accessing a specific index of the structure. We introduce new `pos` functions to replace them.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/flat-flies-hear.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`SimulateCall`: Add a new call simulation utilities that allow inspecting return data from contract calls by executing them in a non-mutating, revert-based context.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/floppy-symbols-burn.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`CrosschainRemoteExecutor`: Add a new executor contract that relays transaction from a controller on a remote chain.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/fruity-coats-smash.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`BridgeNonFungibleCore` and `BridgeERC721`: Added bridge contracts to handle crosschain movements of ERC-721 tokens.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/gentle-apples-dance.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`Accumulator`: Check that slices being added (`shift` or `push`) are in the reserved space.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/happy-pants-decide.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': patch
---
Rename `BridgeERC20Core` to `BridgeFungible`

5
packages/contracts/lib/openzeppelin-contracts/.changeset/heavy-pots-reply.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': patch
---
`ERC1155Burnable`: use `_checkAuthorized` to correctly apply authorization overrides

5
packages/contracts/lib/openzeppelin-contracts/.changeset/legal-cameras-sin.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`AccessManager`: treat `setAuthority` differently in `canCall` to prevent bypassing the `updateAuthority` security using an `execute`.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/metal-chicken-dress.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`ERC20TransferAuthorization`: Add an ERC-20 extension implementing ERC-3009's transfer with authorization using parallel nonces.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/noisy-dragons-paint.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`DoubleEndedQueue`: Add `values(deque, start, end)` to return a slice of the queue as an array, mirroring the paginated `values` accessor in `EnumerableSet`. Out-of-bound values for `start` and `end` are clamped to the queue length.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/polite-cups-shine.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`PaymasterERC20Guarantor`: Add extension of `PaymasterERC20` that enables third parties to guarantee user operations by prefunding gas costs upfront, with repayment handling for successful operations.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/polite-geckos-peel.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`PaymasterERC20`: Extension of `Paymaster` that sponsors user operations against payment in ERC-20 tokens.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/quiet-otters-jump.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`ERC1967Clones`: Add a library to deploy minimal ERC-1967 proxies via `CREATE` or `CREATE2`.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/rare-bushes-march.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`GovernorCrosschain`: Governor module that facilitates the execution of crosschain operations through CrosschainRemoteExecutors and ERC-7786 gateways.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/red-gifts-appear.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': patch
---
`InteroperableAddress`: Fix overflow in the parsing functions that caused silent misparse of large interoperable addresses.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/shy-poets-look.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`PaymasterSigner`: Extension of `Paymaster` that approves sponsoring of user operation based on a cryptographic signature verified by the paymaster.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/silver-falcons-lay.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`Governor`: Strict enforcement of the expected proposal state depending on `proposalNeedsQueuing` when calling `execute`.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/slimy-pugs-shop.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': patch
---
`ERC7913WebAuthnVerifier`: Add an internal `_requireUV` function that can be overridden to disable the UV check

5
packages/contracts/lib/openzeppelin-contracts/.changeset/smooth-cows-notice.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`InteroperableAddress`: reject inputs with both chain reference and addresses empty.

5
packages/contracts/lib/openzeppelin-contracts/.changeset/some-dolls-shine.md Normal file
View file

@ -0,0 +1,5 @@
---
'openzeppelin-solidity': minor
---
`ERC2771Forwarder`: Revert the entire atomic batch if a call with value fails.

Some files were not shown because too many files have changed in this diff Show more