Struct Config

pub struct Config {

    pub profile: Profile,
    pub profiles: Vec<Profile>,
    pub root: PathBuf,
    pub src: PathBuf,
    pub test: PathBuf,
    pub script: PathBuf,
    pub out: PathBuf,
    pub libs: Vec<PathBuf>,
    pub remappings: Vec<RelativeRemapping>,
    pub auto_detect_remappings: bool,
    pub libraries: Vec<String>,
    pub cache: bool,
    pub cache_path: PathBuf,
    pub snapshots: PathBuf,
    pub broadcast: PathBuf,
    pub allow_paths: Vec<PathBuf>,
    pub include_paths: Vec<PathBuf>,
    pub skip: Vec<GlobMatcher>,
    pub force: bool,
    pub evm_version: EvmVersion,
    pub gas_reports: Vec<String>,
    pub gas_reports_ignore: Vec<String>,
    pub gas_reports_include_tests: bool,
    pub solc: Option<SolcReq>,
    pub auto_detect_solc: bool,
    pub offline: bool,
    pub optimizer: bool,
    pub optimizer_runs: usize,
    pub optimizer_details: Option<OptimizerDetails>,
    pub model_checker: Option<ModelCheckerSettings>,
    pub verbosity: u8,
    pub eth_rpc_url: Option<String>,
    pub eth_rpc_jwt: Option<String>,
    pub eth_rpc_timeout: Option<u64>,
    pub eth_rpc_headers: Option<Vec<String>>,
    pub etherscan_api_key: Option<String>,
    pub etherscan: EtherscanConfigs,
    pub ignored_error_codes: Vec<SolidityErrorCode>,
    pub ignored_file_paths: Vec<PathBuf>,
    pub deny_warnings: bool,
    pub test_pattern: Option<RegexWrapper>,
    pub test_pattern_inverse: Option<RegexWrapper>,
    pub contract_pattern: Option<RegexWrapper>,
    pub contract_pattern_inverse: Option<RegexWrapper>,
    pub path_pattern: Option<Glob>,
    pub path_pattern_inverse: Option<Glob>,
    pub coverage_pattern_inverse: Option<RegexWrapper>,
    pub test_failures_file: PathBuf,
    pub threads: Option<usize>,
    pub show_progress: bool,
    pub fuzz: FuzzConfig,
    pub invariant: InvariantConfig,
    pub ffi: bool,
    pub always_use_create_2_factory: bool,
    pub prompt_timeout: u64,
    pub sender: Address,
    pub tx_origin: Address,
    pub initial_balance: U256,
    pub block_number: u64,
    pub fork_block_number: Option<u64>,
    pub chain: Option<Chain>,
    pub gas_limit: GasLimit,
    pub code_size_limit: Option<usize>,
    pub gas_price: Option<u64>,
    pub block_base_fee_per_gas: u64,
    pub block_coinbase: Address,
    pub block_timestamp: u64,
    pub block_difficulty: u64,
    pub block_prevrandao: B256,
    pub block_gas_limit: Option<GasLimit>,
    pub memory_limit: u64,
    pub extra_output: Vec<ContractOutputSelection>,
    pub extra_output_files: Vec<ContractOutputSelection>,
    pub names: bool,
    pub sizes: bool,
    pub via_ir: bool,
    pub ast: bool,
    pub rpc_storage_caching: StorageCachingConfig,
    pub no_storage_caching: bool,
    pub no_rpc_rate_limit: bool,
    pub rpc_endpoints: RpcEndpoints,
    pub use_literal_content: bool,
    pub bytecode_hash: BytecodeHash,
    pub cbor_metadata: bool,
    pub revert_strings: Option<RevertStrings>,
    pub sparse_mode: bool,
    pub build_info: bool,
    pub build_info_path: Option<PathBuf>,
    pub fmt: FormatterConfig,
    pub doc: DocConfig,
    pub bind_json: BindJsonConfig,
    pub fs_permissions: FsPermissions,
    pub isolate: bool,
    pub disable_block_gas_limit: bool,
    pub labels: AddressHashMap<String>,
    pub unchecked_cheatcode_artifacts: bool,
    pub create2_library_salt: B256,
    pub create2_deployer: Address,
    pub vyper: VyperConfig,
    pub dependencies: Option<SoldeerDependencyConfig>,
    pub soldeer: Option<SoldeerConfig>,
    pub assertions_revert: bool,
    pub legacy_assertions: bool,
    pub extra_args: Vec<String>,
    pub eof_version: Option<EofVersion>,
    pub odyssey: bool,
    pub transaction_timeout: u64,
    pub eof: bool,
    pub warnings: Vec<Warning>,
    pub additional_compiler_profiles: Vec<SettingsOverrides>,
    pub compilation_restrictions: Vec<CompilationRestrictions>,
    /* private fields */
}

Foundry configuration

Defaults

All configuration values have a default, documented in the fields section below. Config::default() returns the default values for the default profile while Config::with_root() returns the values based on the given directory. Config::load() starts with the default profile and merges various providers into the config, same for Config::load_with_root(), but there the default values are determined by Config::with_root()

Provider Details

Config is a Figment [Provider] with the following characteristics:

• Profile

  The profile is set to the value of the profile field.

• Metadata

  This provider is named Foundry Config. It does not specify a Source and uses default interpolation.

• Data

  The data emitted by this provider are the keys and values corresponding to the fields and values of the structure. The dictionary is emitted to the “default” meta-profile.

Note that these behaviors differ from those of Config::figment().

Fields

profile: Profile

The selected profile. (default: default default)

Note: This field is never serialized nor deserialized. When a Config is merged into a Figment as a Provider, this profile is selected on the Figment. When a Config is extracted, this field is set to the extracting Figment’s selected Profile.

profiles: Vec<Profile>

The list of all profiles defined in the config.

See profile.

root: PathBuf

The root path where the config detection started from, Config::with_root.

src: PathBuf

path of the source contracts dir, like src or contracts

test: PathBuf

path of the test dir

script: PathBuf

path of the script dir

out: PathBuf

path to where artifacts shut be written to

libs: Vec<PathBuf>

all library folders to include, lib, node_modules

remappings: Vec<RelativeRemapping>

Remappings to use for this repo

auto_detect_remappings: bool

Whether to autodetect remappings by scanning the libs folders recursively

libraries: Vec<String>

library addresses to link

cache: bool

whether to enable cache

cache_path: PathBuf

where the cache is stored if enabled

snapshots: PathBuf

where the gas snapshots are stored

broadcast: PathBuf

where the broadcast logs are stored

allow_paths: Vec<PathBuf>

additional solc allow paths for --allow-paths

include_paths: Vec<PathBuf>

additional solc include paths for --include-path

skip: Vec<GlobMatcher>

glob patterns to skip

force: bool

whether to force a project.clean()

evm_version: EvmVersion

evm version to use

gas_reports: Vec<String>

list of contracts to report gas of

gas_reports_ignore: Vec<String>

list of contracts to ignore for gas reports

gas_reports_include_tests: bool

Whether to include gas reports for tests.

solc: Option<SolcReq>

The Solc instance to use if any.

This takes precedence over auto_detect_solc, if a version is set then this overrides auto-detection.

Note for backwards compatibility reasons this also accepts solc_version from the toml file, see BackwardsCompatTomlProvider.

auto_detect_solc: bool

whether to autodetect the solc compiler version to use

offline: bool

Offline mode, if set, network access (downloading solc) is disallowed.

Relationship with auto_detect_solc:

• if auto_detect_solc = true and offline = true, the required solc version(s) will be auto detected but if the solc version is not installed, it will not try to install it

optimizer: bool

Whether to activate optimizer

optimizer_runs: usize

The number of runs specifies roughly how often each opcode of the deployed code will be executed across the life-time of the contract. This means it is a trade-off parameter between code size (deploy cost) and code execution cost (cost after deployment). An optimizer_runs parameter of 1 will produce short but expensive code. In contrast, a larger optimizer_runs parameter will produce longer but more gas efficient code. The maximum value of the parameter is 2**32-1.

A common misconception is that this parameter specifies the number of iterations of the optimizer. This is not true: The optimizer will always run as many times as it can still improve the code.

optimizer_details: Option<OptimizerDetails>

Switch optimizer components on or off in detail. The “enabled” switch above provides two defaults which can be tweaked here. If “details” is given, “enabled” can be omitted.

model_checker: Option<ModelCheckerSettings>

Model checker settings.

verbosity: u8

verbosity to use

eth_rpc_url: Option<String>

url of the rpc server that should be used for any rpc calls

eth_rpc_jwt: Option<String>

JWT secret that should be used for any rpc calls

eth_rpc_timeout: Option<u64>

Timeout that should be used for any rpc calls

eth_rpc_headers: Option<Vec<String>>

Headers that should be used for any rpc calls

Example

rpc_headers = [“x-custom-header:value”, “x-another-header:another-value”]

You can also the ETH_RPC_HEADERS env variable like so: ETH_RPC_HEADERS="x-custom-header:value x-another-header:another-value"

etherscan_api_key: Option<String>

etherscan API key, or alias for an EtherscanConfig in etherscan table

etherscan: EtherscanConfigs

Multiple etherscan api configs and their aliases

ignored_error_codes: Vec<SolidityErrorCode>

list of solidity error codes to always silence in the compiler output

ignored_file_paths: Vec<PathBuf>

list of file paths to ignore

deny_warnings: bool

When true, compiler warnings are treated as errors

test_pattern: Option<RegexWrapper>

Only run test functions matching the specified regex pattern.

test_pattern_inverse: Option<RegexWrapper>

Only run test functions that do not match the specified regex pattern.

contract_pattern: Option<RegexWrapper>

Only run tests in contracts matching the specified regex pattern.

contract_pattern_inverse: Option<RegexWrapper>

Only run tests in contracts that do not match the specified regex pattern.

path_pattern: Option<Glob>

Only run tests in source files matching the specified glob pattern.

path_pattern_inverse: Option<Glob>

Only run tests in source files that do not match the specified glob pattern.

coverage_pattern_inverse: Option<RegexWrapper>

Only show coverage for files that do not match the specified regex pattern.

test_failures_file: PathBuf

Path where last test run failures are recorded.

threads: Option<usize>

Max concurrent threads to use.

show_progress: bool

Whether to show test execution progress.

fuzz: FuzzConfig

Configuration for fuzz testing

invariant: InvariantConfig

Configuration for invariant testing

ffi: bool

Whether to allow ffi cheatcodes in test

always_use_create_2_factory: bool

Use the create 2 factory in all cases including tests and non-broadcasting scripts.

prompt_timeout: u64

Sets a timeout in seconds for vm.prompt cheatcodes

sender: Address

The address which will be executing all tests

tx_origin: Address

The tx.origin value during EVM execution

initial_balance: U256

the initial balance of each deployed test contract

block_number: u64

the block.number value during EVM execution

fork_block_number: Option<u64>

pins the block number for the state fork

chain: Option<Chain>

The chain name or EIP-155 chain ID.

gas_limit: GasLimit

Block gas limit.

code_size_limit: Option<usize>

EIP-170: Contract code size limit in bytes. Useful to increase this because of tests.

gas_price: Option<u64>

tx.gasprice value during EVM execution.

This is an Option, so we can determine in fork mode whether to use the config’s gas price (if set by user) or the remote client’s gas price.

block_base_fee_per_gas: u64

The base fee in a block.

block_coinbase: Address

The block.coinbase value during EVM execution.

block_timestamp: u64

The block.timestamp value during EVM execution.

block_difficulty: u64

The block.difficulty value during EVM execution.

block_prevrandao: B256

Before merge the block.max_hash, after merge it is block.prevrandao.

block_gas_limit: Option<GasLimit>

The block.gaslimit value during EVM execution.

memory_limit: u64

The memory limit per EVM execution in bytes. If this limit is exceeded, a MemoryLimitOOG result is thrown.

The default is 128MiB.

extra_output: Vec<ContractOutputSelection>

Additional output selection for all contracts, such as “ir”, “devdoc”, “storageLayout”, etc.

See the Solc Compiler Api for more information.

The following values are always set because they’re required by forge:

{
  "*": [
      "abi",
      "evm.bytecode",
      "evm.deployedBytecode",
      "evm.methodIdentifiers"
    ]
}

extra_output_files: Vec<ContractOutputSelection>

If set, a separate JSON file will be emitted for every contract depending on the selection, eg. extra_output_files = ["metadata"] will create a metadata.json for each contract in the project.

See Contract Metadata for more information.

The difference between extra_output = ["metadata"] and extra_output_files = ["metadata"] is that the former will include the contract’s metadata in the contract’s json artifact, whereas the latter will emit the output selection as separate files.

names: bool

Whether to print the names of the compiled contracts.

sizes: bool

Whether to print the sizes of the compiled contracts.

via_ir: bool

If set to true, changes compilation pipeline to go through the Yul intermediate representation.

ast: bool

Whether to include the AST as JSON in the compiler output.

rpc_storage_caching: StorageCachingConfig

RPC storage caching settings determines what chains and endpoints to cache

no_storage_caching: bool

Disables storage caching entirely. This overrides any settings made in rpc_storage_caching

no_rpc_rate_limit: bool

Disables rate limiting entirely. This overrides any settings made in compute_units_per_second

rpc_endpoints: RpcEndpoints

Multiple rpc endpoints and their aliases

use_literal_content: bool

Whether to store the referenced sources in the metadata as literal data.

bytecode_hash: BytecodeHash

Whether to include the metadata hash.

The metadata hash is machine dependent. By default, this is set to [BytecodeHash::None] to allow for deterministic code, See: https://docs.soliditylang.org/en/latest/metadata.html

cbor_metadata: bool

Whether to append the metadata hash to the bytecode.

If this is false and the bytecode_hash option above is not None solc will issue a warning.

revert_strings: Option<RevertStrings>

How to treat revert (and require) reason strings.

sparse_mode: bool

Whether to compile in sparse mode

If this option is enabled, only the required contracts/files will be selected to be included in solc’s output selection, see also [OutputSelection].

build_info: bool

Generates additional build info json files for every new build, containing the CompilerInput and CompilerOutput.

build_info_path: Option<PathBuf>

The path to the build-info directory that contains the build info json files.

fmt: FormatterConfig

Configuration for forge fmt

doc: DocConfig

Configuration for forge doc

bind_json: BindJsonConfig

Configuration for forge bind-json

fs_permissions: FsPermissions

Configures the permissions of cheat codes that touch the file system.

This includes what operations can be executed (read, write)

isolate: bool

Whether to enable call isolation.

Useful for more correct gas accounting and EVM behavior in general.

disable_block_gas_limit: bool

Whether to disable the block gas limit.

labels: AddressHashMap<String>

Address labels

unchecked_cheatcode_artifacts: bool

Whether to enable safety checks for vm.getCode and vm.getDeployedCode invocations. If disabled, it is possible to access artifacts which were not recompiled or cached.

create2_library_salt: B256

CREATE2 salt to use for the library deployment in scripts.

create2_deployer: Address

The CREATE2 deployer address to use.

vyper: VyperConfig

Configuration for Vyper compiler

dependencies: Option<SoldeerDependencyConfig>

Soldeer dependencies

soldeer: Option<SoldeerConfig>

Soldeer custom configs

assertions_revert: bool

Whether failed assertions should revert.

Note that this only applies to native (cheatcode) assertions, invoked on Vm contract.

legacy_assertions: bool

Whether failed() should be invoked to check if the test have failed.

extra_args: Vec<String>

Optional additional CLI arguments to pass to solc binary.

eof_version: Option<EofVersion>

Optional EOF version.

odyssey: bool

Whether to enable Odyssey features.

transaction_timeout: u64

Timeout for transactions in seconds.

eof: bool

Use EOF-enabled solc for compilation.

warnings: Vec<Warning>

Warnings gathered when loading the Config. See WarningsProvider for more information.

additional_compiler_profiles: Vec<SettingsOverrides>

Additional settings profiles to use when compiling.

compilation_restrictions: Vec<CompilationRestrictions>

Restrictions on compilation of certain files.

Implementations

impl Config

pub const DEFAULT_PROFILE: Profile = Profile::Default

The default profile: “default”

pub const HARDHAT_PROFILE: Profile

The hardhat profile: “hardhat”

pub const PROFILE_SECTION: &'static str = "profile"

TOML section for profiles

pub const STANDALONE_SECTIONS: &'static [&'static str]

Standalone sections in the config which get integrated into the selected profile

pub const FILE_NAME: &'static str = "foundry.toml"

File name of config toml file

pub const FOUNDRY_DIR_NAME: &'static str = ".foundry"

The name of the directory foundry reserves for itself under the user’s home directory: ~

pub const DEFAULT_SENDER: Address

Default address for tx.origin

0x1804c8AB1F12E6bbf3894d4083f33e07309d1f38

pub const DEFAULT_CREATE2_LIBRARY_SALT: FixedBytes<32> = FixedBytes<32>::ZERO

Default salt for create2 library deployments

pub const DEFAULT_CREATE2_DEPLOYER: Address

Default create2 deployer

pub const EOF_SOLC_IMAGE: &'static str = "ghcr.io/paradigmxyz/forge-eof@sha256:46f868ce5264e1190881a3a335d41d7f42d6f26ed20b0c823609c715e38d603f"

Docker image with eof-enabled solc binary

pub fn load() -> Self

Returns the current Config

See figment for more details.

pub fn load_with_providers(providers: FigmentProviders) -> Self

Returns the current Config with the given providers preset

See figment for more details.

pub fn load_with_root(root: impl AsRef<Path>) -> Self

Returns the current Config

See figment_with_root for more details.

pub fn from_provider<T: Provider>(provider: T) -> Self

Extract a Config from provider, panicking if extraction fails.

Panics

If extraction fails, prints an error message indicating the failure and panics. For a version that doesn’t panic, use Config::try_from().

Example

use figment::providers::{Env, Format, Toml};
use foundry_config::Config;

// Use foundry's default `Figment`, but allow values from `other.toml`
// to supersede its values.
let figment = Config::figment().merge(Toml::file("other.toml").nested());

let config = Config::from_provider(figment);

pub fn try_from<T: Provider>(provider: T) -> Result<Self, ExtractConfigError>

Attempts to extract a Config from provider, returning the result.

Example

use figment::providers::{Env, Format, Toml};
use foundry_config::Config;

// Use foundry's default `Figment`, but allow values from `other.toml`
// to supersede its values.
let figment = Config::figment().merge(Toml::file("other.toml").nested());

let config = Config::try_from(figment);

pub(crate) fn try_from_figment( figment: Figment, ) -> Result<Self, ExtractConfigError>

pub fn to_figment(&self, providers: FigmentProviders) -> Figment

Returns the populated [Figment] using the requested FigmentProviders preset.

This will merge various providers, such as env,toml,remappings into the figment if requested.

pub fn canonic(self) -> Self

The config supports relative paths and tracks the root path separately see Config::with_root

This joins all relative paths with the current root and attempts to make them canonic

pub fn canonic_at(self, root: impl Into<PathBuf>) -> Self

Joins all relative paths with the given root so that paths that are defined as:

[profile.default]
src = "src"
out = "./out"
libs = ["lib", "/var/lib"]

Will be made canonic with the given root:

[profile.default]
src = "<root>/src"
out = "<root>/out"
libs = ["<root>/lib", "/var/lib"]

pub fn normalized_evm_version(self) -> Self

Normalizes the evm version if a SolcReq is set

pub fn normalize_evm_version(&mut self)

Normalizes the evm version if a SolcReq is set to a valid version.

pub fn get_normalized_evm_version(&self) -> EvmVersion

Returns the normalized [EvmVersion] if a SolcReq is set to a valid version or if the solc path is a valid solc binary.

Otherwise it returns the configured [EvmVersion].

pub fn sanitized(self) -> Self

Returns a sanitized version of the Config where are paths are set correctly and potential duplicates are resolved

See Self::canonic

pub fn sanitize_remappings(&mut self)

Cleans up any duplicate Remapping and sorts them

On windows this will convert any \ in the remapping path into a /

pub fn sanitize_eof_settings(&mut self)

Adjusts settings if EOF compilation is enabled.

This includes enabling via_ir, eof_version and ensuring that evm_version is not lower than Prague.

pub fn install_lib_dir(&self) -> &Path

Returns the directory in which dependencies should be installed

Returns the first dir from libs that is not node_modules or lib if libs is empty

pub fn project(&self) -> Result<Project<MultiCompiler>, SolcError>

Serves as the entrypoint for obtaining the project.

Returns the Project configured with all solc and path related values.

Note: this also cleans [Project::cleanup] the workspace if force is set to true.

Example

use foundry_config::Config;
let config = Config::load_with_root(".").sanitized();
let project = config.project();

pub fn ephemeral_no_artifacts_project( &self, ) -> Result<Project<MultiCompiler>, SolcError>

Same as Self::project() but sets configures the project to not emit artifacts and ignore cache.

pub(crate) fn additional_settings( &self, base: &MultiCompilerSettings, ) -> BTreeMap<String, MultiCompilerSettings>

Builds mapping with additional settings profiles.

pub(crate) fn restrictions( &self, paths: &ProjectPathsConfig, ) -> Result<BTreeMap<PathBuf, RestrictionsWithVersion<MultiCompilerRestrictions>>, SolcError>

Resolves globs and builds a mapping from individual source files to their restrictions

pub fn create_project( &self, cached: bool, no_artifacts: bool, ) -> Result<Project, SolcError>

Creates a [Project] with the given cached and no_artifacts flags

pub fn cleanup<C: Compiler, T: ArtifactOutput<CompilerContract = C::CompilerContract>>( &self, project: &Project<C, T>, ) -> Result<(), SolcError>

Cleans the project.

pub(crate) fn ensure_solc(&self) -> Result<Option<Solc>, SolcError>

Ensures that the configured version is installed if explicitly set

If solc is SolcReq::Version then this will download and install the solc version if it’s missing, unless the offline flag is enabled, in which case an error is thrown.

If solc is SolcReq::Local then this will ensure that the path exists.

pub fn evm_spec_id(&self) -> SpecId

Returns the [SpecId] derived from the configured [EvmVersion]

pub fn is_auto_detect(&self) -> bool

Returns whether the compiler version should be auto-detected

Returns false if solc_version is explicitly set, otherwise returns the value of auto_detect_solc

pub fn enable_caching(&self, endpoint: &str, chain_id: impl Into<u64>) -> bool

Whether caching should be enabled for the given chain id

pub fn project_paths<L>(&self) -> ProjectPathsConfig<L>

Returns the ProjectPathsConfig sub set of the config.

NOTE: this uses the paths as they are and does not modify them, see [Self::sanitized]

Example

use foundry_compilers::solc::Solc;
use foundry_config::Config;
let config = Config::load_with_root(".").sanitized();
let paths = config.project_paths::<Solc>();

pub fn solc_compiler(&self) -> Result<SolcCompiler, SolcError>

Returns configuration for a compiler to use when setting up a [Project].

pub fn vyper_compiler(&self) -> Result<Option<Vyper>, SolcError>

Returns configured [Vyper] compiler.

pub fn compiler(&self) -> Result<MultiCompiler, SolcError>

Returns configuration for a compiler to use when setting up a [Project].

pub fn compiler_settings(&self) -> Result<MultiCompilerSettings, SolcError>

Returns configured [MultiCompilerSettings].

pub fn get_all_remappings(&self) -> impl Iterator<Item = Remapping> + '_

Returns all configured remappings.

pub fn get_rpc_jwt_secret( &self, ) -> Result<Option<Cow<'_, str>>, UnresolvedEnvVarError>

Returns the configured rpc jwt secret

Returns:

• The jwt secret, if configured

Example

use foundry_config::Config;
let config = Config::with_root("./");
let rpc_jwt = config.get_rpc_jwt_secret().unwrap().unwrap();

pub fn get_rpc_url(&self) -> Option<Result<Cow<'_, str>, UnresolvedEnvVarError>>

Returns the configured rpc url

Returns:

• the matching, resolved url of rpc_endpoints if eth_rpc_url is an alias
• the eth_rpc_url as-is if it isn’t an alias

Example

use foundry_config::Config;
let config = Config::with_root("./");
let rpc_url = config.get_rpc_url().unwrap().unwrap();

pub fn get_rpc_url_with_alias( &self, maybe_alias: &str, ) -> Option<Result<Cow<'_, str>, UnresolvedEnvVarError>>

Resolves the given alias to a matching rpc url

Returns

In order of resolution:

• the matching, resolved url of rpc_endpoints if maybe_alias is an alias
• a mesc resolved url if maybe_alias is a known alias in mesc
• None otherwise

Note on mesc

The endpoint is queried for in mesc under the foundry profile, allowing users to customize endpoints for Foundry specifically.

Example

use foundry_config::Config;
let config = Config::with_root("./");
let rpc_url = config.get_rpc_url_with_alias("mainnet").unwrap().unwrap();

pub fn get_rpc_url_or<'a>( &'a self, fallback: impl Into<Cow<'a, str>>, ) -> Result<Cow<'a, str>, UnresolvedEnvVarError>

Returns the configured rpc, or the fallback url

Example

use foundry_config::Config;
let config = Config::with_root("./");
let rpc_url = config.get_rpc_url_or("http://localhost:8545").unwrap();

pub fn get_rpc_url_or_localhost_http( &self, ) -> Result<Cow<'_, str>, UnresolvedEnvVarError>

Returns the configured rpc or "http://localhost:8545" if no eth_rpc_url is set

Example

use foundry_config::Config;
let config = Config::with_root("./");
let rpc_url = config.get_rpc_url_or_localhost_http().unwrap();

pub fn get_etherscan_config( &self, ) -> Option<Result<ResolvedEtherscanConfig, EtherscanConfigError>>

Returns the EtherscanConfig to use, if any

Returns

• the matching ResolvedEtherscanConfig of the etherscan table if etherscan_api_key is an alias
• the matching ResolvedEtherscanConfig of the etherscan table if a chain is configured. an alias
• the Mainnet ResolvedEtherscanConfig if etherscan_api_key is set, None otherwise

Example

use foundry_config::Config;
let config = Config::with_root("./");
let etherscan_config = config.get_etherscan_config().unwrap().unwrap();
let client = etherscan_config.into_client().unwrap();

pub fn get_etherscan_config_with_chain( &self, chain: Option<Chain>, ) -> Result<Option<ResolvedEtherscanConfig>, EtherscanConfigError>

Same as Self::get_etherscan_config() but optionally updates the config with the given chain, and etherscan_api_key

If not matching alias was found, then this will try to find the first entry in the table with a matching chain id. If an etherscan_api_key is already set it will take precedence over the chain’s entry in the table.

pub fn get_etherscan_api_key(&self, chain: Option<Chain>) -> Option<String>

Helper function to just get the API key

Optionally updates the config with the given chain.

See also Self::get_etherscan_config_with_chain

pub fn get_source_dir_remapping(&self) -> Option<Remapping>

Returns the remapping for the project’s src directory

Note: this will add an additional <src>/=<src path> remapping here so imports that look like import {Foo} from "src/Foo.sol"; are properly resolved.

This is due the fact that solc’s VFS resolves direct imports that start with the source directory’s name.

pub fn get_test_dir_remapping(&self) -> Option<Remapping>

Returns the remapping for the project’s test directory, but only if it exists

pub fn get_script_dir_remapping(&self) -> Option<Remapping>

Returns the remapping for the project’s script directory, but only if it exists

pub fn optimizer(&self) -> Optimizer

Returns the Optimizer based on the configured settings

Note: optimizer details can be set independently of enabled See also: https://github.com/foundry-rs/foundry/issues/7689 and https://github.com/ethereum/solidity/blob/bbb7f58be026fdc51b0b4694a6f25c22a1425586/docs/using-the-compiler.rst?plain=1#L293-L294

pub fn configured_artifacts_handler(&self) -> ConfigurableArtifacts

returns the [foundry_compilers::ConfigurableArtifacts] for this config, that includes the extra_output fields

pub fn parsed_libraries(&self) -> Result<Libraries, SolcError>

Parses all libraries in the form of <file>:<lib>:<addr>

pub fn libraries_with_remappings(&self) -> Result<Libraries, SolcError>

Returns all libraries with applied remappings. Same as self.solc_settings()?.libraries.

pub fn solc_settings(&self) -> Result<SolcSettings, SolcError>

Returns the configured solc Settings that includes:

• all libraries
• the optimizer (including details, if configured)
• evm version

pub fn vyper_settings(&self) -> Result<VyperSettings, SolcError>

Returns the configured [VyperSettings] that includes:

• evm version

pub fn figment() -> Figment

Returns the default figment

The default figment reads from the following sources, in ascending priority order:

1. Config::default() (see defaults)
2. foundry.toml or filename in FOUNDRY_CONFIG environment variable
3. FOUNDRY_ prefixed environment variables

The profile selected is the value set in the FOUNDRY_PROFILE environment variable. If it is not set, it defaults to default.

Example

use foundry_config::Config;
use serde::Deserialize;

let my_config = Config::figment().extract::<Config>();

pub fn figment_with_root(root: impl AsRef<Path>) -> Figment

Returns the default figment enhanced with additional context extracted from the provided root, like remappings and directories.

Example

use foundry_config::Config;
use serde::Deserialize;

let my_config = Config::figment_with_root(".").extract::<Config>();

pub fn with_root(root: impl AsRef<Path>) -> Self

Creates a new Config that adds additional context extracted from the provided root.

Example

use foundry_config::Config;
let my_config = Config::with_root(".");

pub(crate) fn _with_root(root: &Path) -> Self

pub fn hardhat() -> Self

Returns the default config but with hardhat paths

pub fn dapptools() -> Self

Returns the default config that uses dapptools style paths

pub fn into_basic(self) -> BasicConfig

Extracts a basic subset of the config, used for initialisations.

Example

use foundry_config::Config;
let my_config = Config::with_root(".").into_basic();

pub fn update_at<F>(root: &Path, f: F) -> Result<()>

where F: FnOnce(&Self, &mut DocumentMut) -> bool,

Updates the foundry.toml file for the given root based on the provided closure.

Note: the closure will only be invoked if the foundry.toml file exists, See Self::get_config_path() and if the closure returns true.

pub fn update<F>(&self, f: F) -> Result<()>

where F: FnOnce(&mut DocumentMut) -> bool,

Updates the foundry.toml file this Config ias based on with the provided closure.

Note: the closure will only be invoked if the foundry.toml file exists, See Self::get_config_path() and if the closure returns true

pub fn update_libs(&self) -> Result<()>

Sets the libs entry inside a foundry.toml file but only if it exists

Errors

An error if the foundry.toml could not be parsed.

pub fn to_string_pretty(&self) -> Result<String, Error>

Serialize the config type as a String of TOML.

This serializes to a table with the name of the profile

[profile.default]
src = "src"
out = "out"
libs = ["lib"]
# ...

pub fn get_config_path(&self) -> PathBuf

Returns the path to the foundry.toml of this Config.

pub fn selected_profile() -> Profile

Returns the selected profile.

If the FOUNDRY_PROFILE env variable is not set, this returns the DEFAULT_PROFILE.

pub(crate) fn force_selected_profile() -> Profile

pub fn foundry_dir_toml() -> Option<PathBuf>

Returns the path to foundry’s global TOML file: ~/.foundry/foundry.toml.

pub fn foundry_dir() -> Option<PathBuf>

Returns the path to foundry’s config dir: ~/.foundry/.

pub fn foundry_cache_dir() -> Option<PathBuf>

Returns the path to foundry’s cache dir: ~/.foundry/cache.

pub fn foundry_rpc_cache_dir() -> Option<PathBuf>

Returns the path to foundry rpc cache dir: ~/.foundry/cache/rpc.

pub fn foundry_chain_cache_dir(chain_id: impl Into<Chain>) -> Option<PathBuf>

Returns the path to foundry chain’s cache dir: ~/.foundry/cache/rpc/<chain>

pub fn foundry_etherscan_cache_dir() -> Option<PathBuf>

Returns the path to foundry’s etherscan cache dir: ~/.foundry/cache/etherscan.

pub fn foundry_keystores_dir() -> Option<PathBuf>

Returns the path to foundry’s keystores dir: ~/.foundry/keystores.

pub fn foundry_etherscan_chain_cache_dir( chain_id: impl Into<Chain>, ) -> Option<PathBuf>

Returns the path to foundry’s etherscan cache dir for chain_id: ~/.foundry/cache/etherscan/<chain>

pub fn foundry_block_cache_dir( chain_id: impl Into<Chain>, block: u64, ) -> Option<PathBuf>

Returns the path to the cache dir of the block on the chain: ~/.foundry/cache/rpc/<chain>/<block>

pub fn foundry_block_cache_file( chain_id: impl Into<Chain>, block: u64, ) -> Option<PathBuf>

Returns the path to the cache file of the block on the chain: ~/.foundry/cache/rpc/<chain>/<block>/storage.json

pub fn data_dir() -> Result<PathBuf>

Returns the path to foundry’s data directory inside the user’s data directory.

Platform	Value	Example
Linux	$XDG_CONFIG_HOME or $HOME/.config/foundry	/home/alice/.config/foundry
macOS	$HOME/Library/Application Support/foundry	/Users/Alice/Library/Application Support/foundry
Windows	{FOLDERID_RoamingAppData}/foundry	C:\Users\Alice\AppData\Roaming/foundry

pub fn find_config_file() -> Option<PathBuf>

Returns the path to the foundry.toml file, the file is searched for in the current working directory and all parent directories until the root, and the first hit is used.

If this search comes up empty, then it checks if a global foundry.toml exists at ~/.foundry/foundry.toml, see Self::foundry_dir_toml.

pub fn clean_foundry_cache() -> Result<()>

Clears the foundry cache.

pub fn clean_foundry_chain_cache(chain: Chain) -> Result<()>

Clears the foundry cache for chain.

pub fn clean_foundry_block_cache(chain: Chain, block: u64) -> Result<()>

Clears the foundry cache for chain and block.

pub fn clean_foundry_etherscan_cache() -> Result<()>

Clears the foundry etherscan cache.

pub fn clean_foundry_etherscan_chain_cache(chain: Chain) -> Result<()>

Clears the foundry etherscan cache for chain.

pub fn list_foundry_cache() -> Result<Cache>

List the data in the foundry cache.

pub fn list_foundry_chain_cache(chain: Chain) -> Result<ChainCache>

List the cached data for chain.

pub(crate) fn get_cached_blocks(chain_path: &Path) -> Result<Vec<(String, u64)>>

The path provided to this function should point to a cached chain folder.

pub(crate) fn get_cached_block_explorer_data(chain_path: &Path) -> Result<u64>

The path provided to this function should point to the etherscan cache for a chain.

pub(crate) fn merge_toml_provider( figment: Figment, toml_provider: impl Provider, profile: Profile, ) -> Figment

pub(crate) fn normalize_defaults(&self, figment: Figment) -> Figment

Check if any defaults need to be normalized.

This normalizes the default evm_version if a solc was provided in the config.

See also https://github.com/foundry-rs/foundry/issues/7014

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Config

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<&Config> for Figment

fn from(c: &Config) -> Self

Converts to this type from the input type.

impl From<Config> for Figment

fn from(c: Config) -> Self

Converts to this type from the input type.

impl PartialEq for Config

fn eq(&self, other: &Config) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Provider for Config

fn metadata(&self) -> Metadata

Returns the [Metadata] for this provider, identifying itself and its configuration sources.

fn data(&self) -> Result<Map<Profile, Dict>, Error>

Returns the configuration data.

fn profile(&self) -> Option<Profile>

Optionally returns a profile to set on the Figment this provider is merged into. The profile is only set if self is merged.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Config

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 2456 bytes