Struct PropertiesArgs 

pub struct PropertiesArgs {

    target: Vec<PathBuf>,
    context: Vec<PathBuf>,
    agent_command: PathBuf,
    agent_arg: Vec<OsString>,
    verifier_command: Option<PathBuf>,
    verifier_arg: Vec<OsString>,
    seed: Vec<U256>,
    agents: usize,
    quorum: Option<usize>,
    timeout: Option<u64>,
    allow_ffi: bool,
    allow_network: bool,
    build: BuildOpts,
}

Run agents that prove bugs with failing tests and report the bugs that they agree on.

Fields

target: Vec<PathBuf>

Source file to look for bugs in. Can be given more than once.

Defaults to every source file in the project’s source directory.

context: Vec<PathBuf>

Reference material for the agents, such as docs, a specification, or a threat model.

Forge gives every agent the absolute path of each file. Can be given more than once.

agent_command: PathBuf

Executable that runs one agent session, such as a wrapper around any coding agent.

Forge runs PATH [ARG...] once per agent, in parallel, each in its own copy of the project, with these environment variables:

FORGE_PROPERTIES_PROMPT the task: targets, context files, and output directory FORGE_PROPERTIES_TARGETS target files, relative to the copy, one per line FORGE_PROPERTIES_CONTEXT absolute paths of the –context files, one per line FORGE_PROPERTIES_OUT absolute, empty directory for the agent’s tests FORGE_PROPERTIES_SEED the agent’s own seed, in hex FORGE_PROPERTIES_USAGE file where the agent can write its model usage as JSON: {“input_tokens”: N, “output_tokens”: N, “cost_usd”: X}

The agent writes Solidity tests under FORGE_PROPERTIES_OUT and can run forge test in the copy. When it exits or reaches –timeout, Forge ends its process group and runs every *.sol file under FORGE_PROPERTIES_OUT in a fresh copy of the project on every seed. A test that fails on every seed is a possible bug. Its claim is the comment right above the test function, // @bug <Contract>.<function> <file>:<line> — <claim>, else the test name. Forge keeps the files whose tests all pass. A nonzero exit status is an error, but Forge still runs the agent’s tests. In Forge’s runs, inline config can only lower runs, depth, and rejects and change a few fuzzer and invariant settings, and a run that takes more than ten minutes ends.

agent_arg: Vec<OsString>

Argument passed to the agent command. Can be given more than once.

verifier_command: Option<PathBuf>

Executable that tries to disprove each possible bug that reaches the quorum, such as a wrapper around any coding agent. Without it, Forge runs no verifier.

Forge runs PATH [ARG...] once per group, at most –agents at a time, each in a fresh copy of the project that also holds the tests of the group, with these environment variables:

FORGE_PROPERTIES_VERIFY_PROMPT the task: try to disprove the claims of the group FORGE_PROPERTIES_GROUP JSON file with the agents, the claims, the tests, and the failure output of the group FORGE_PROPERTIES_VERDICT file where the verifier writes its verdict as JSON: {“verdict”: “confirmed” | “needs_validation” | “rejected”, “reason”: “…”, “evidence”: [{“file”: “…”, “line”: N, “quote”: “…”}], “unresolved”: “…”} FORGE_PROPERTIES_USAGE file where the verifier can write its model usage as JSON, as for an agent

When the verifier exits or reaches –timeout, Forge ends its process group and reads the verdict. Forge lists the confirmed groups first, then the groups that need validation with the open fact, then the rejected groups with the disproof. A missing or invalid verdict, and a rejection without evidence, count as needs_validation. Groups below the quorum are not verified.

verifier_arg: Vec<OsString>

Argument passed to the verifier command. Can be given more than once.

seed: Vec<U256>

Deterministic seeds used to run the tests of every agent. Supply at least two.

agents: usize

Number of agents. Each agent runs one session independently and in parallel in its own copy of the project, with its own seed.

quorum: Option<usize>

Number of agents that must report the same root cause before Forge reports it as a possible bug.

Two failing tests have the same root cause when their @bug tags name the same function in the same Solidity file at near lines. Without both tags, their claims must name the same Solidity file and share a function name at near lines or at least 30% of their words. A test joins a group only when it has the same root cause as every test in it. Forge lists the groups below the quorum after the possible bugs. Defaults to 2, or 1 with a single agent.

timeout: Option<u64>

Seconds after which Forge ends an agent session and runs the tests that it wrote, or ends a verifier and reads its verdict.

allow_ffi: bool

Let generated tests run host commands with vm.ffi if the project enables ffi.

Generated tests run under Forge, outside the sandbox of the agent that wrote them, so Forge turns ffi off in its copies of the project by default.

allow_network: bool

Let generated tests open network connections, for example with vm.createFork.

By default, cheatcodes that open a connection fail in Forge’s copies of the project, and the copies have no RPC or Etherscan settings.

build: BuildOpts

Implementations

impl PropertiesArgs

pub fn run(self) -> Result<()>

Trait Implementations

impl Args for PropertiesArgs

fn group_id() -> Option<Id>

Report the [ArgGroup::id][crate::ArgGroup::id] for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate Self via [FromArgMatches::from_arg_matches_mut]

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to [Command] so it can instantiate self via [FromArgMatches::update_from_arg_matches_mut]

impl Clone for PropertiesArgs

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CommandFactory for PropertiesArgs

fn command<'b>() -> Command

Build a [Command] that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a [Command] that can update self.

impl Debug for PropertiesArgs

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

Formats the value using the given formatter.

impl<'a> From<&'a PropertiesArgs> for Figment

fn from(args: &'a PropertiesArgs) -> Self

Converts to this type from the input type.

impl FromArgMatches for PropertiesArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from [ArgMatches], parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for PropertiesArgs

fn parse() -> Self

Parse from std::env::args_os(), [exit][Error::exit] on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, [exit][Error::exit] on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, [exit][Error::exit] on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Update from iterator, return Err on error.

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: 624 bytes