// 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;
}
}