Struct ethers_solc::ProjectCompileOutput

pub struct ProjectCompileOutput<T: ArtifactOutput = ConfigurableArtifacts> { /* private fields */ }

Contains a mixture of already compiled/cached artifacts and the input set of sources that still need to be compiled.

Implementations

impl<T: ArtifactOutput> ProjectCompileOutput<T>

pub fn slash_paths(&mut self)

Converts all \\ separators in all paths to /

pub fn with_slashed_paths(self) -> Self

Convenience function fo Self::slash_paths()

pub fn into_artifacts(self) -> impl Iterator<Item = (ArtifactId, T::Artifact)>

All artifacts together with their contract file name and name <file name>:<name>

This returns a chained iterator of both cached and recompiled contract artifacts

Example

use std::collections::btree_map::BTreeMap;
use ethers_solc::ConfigurableContractArtifact;
use ethers_solc::{ArtifactId, Project};

let project = Project::builder().build().unwrap();
let contracts: BTreeMap<ArtifactId, ConfigurableContractArtifact> = project.compile().unwrap().into_artifacts().collect();

pub fn artifacts(&self) -> impl Iterator<Item = (String, &T::Artifact)>

This returns a chained iterator of both cached and recompiled contract artifacts that yields the contract name and the corresponding artifact

Example

use std::collections::btree_map::BTreeMap;
use ethers_solc::ConfigurableContractArtifact;
use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let artifacts: BTreeMap<String, &ConfigurableContractArtifact> = project.compile().unwrap().artifacts().collect();

pub fn versioned_artifacts(
    &self
) -> impl Iterator<Item = (String, (&T::Artifact, &Version))>

This returns a chained iterator of both cached and recompiled contract artifacts that yields the contract name and the corresponding artifact

Example

use std::collections::btree_map::BTreeMap;
use semver::Version;
use ethers_solc::ConfigurableContractArtifact;
use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let artifacts: BTreeMap<String, (&ConfigurableContractArtifact, &Version)> = project.compile().unwrap().versioned_artifacts().collect();

pub fn into_artifacts_with_files(
    self
) -> impl Iterator<Item = (String, String, T::Artifact)>

All artifacts together with their contract file and name as tuple (file, contract name, artifact)

This returns a chained iterator of both cached and recompiled contract artifacts

Example

use std::collections::btree_map::BTreeMap;
use ethers_solc::{ConfigurableContractArtifact, Project};

let project = Project::builder().build().unwrap();
let contracts: Vec<(String, String, ConfigurableContractArtifact)> = project.compile().unwrap().into_artifacts_with_files().collect();

NOTE the file will be returned as is, see also Self::with_stripped_file_prefixes()

pub fn into_artifacts_with_sources(
    self
) -> (BTreeMap<ArtifactId, T::Artifact>, VersionedSourceFiles)

All artifacts together with their ID and the sources of the project.

Note: this only returns the SourceFiles for freshly compiled contracts because, if not included in the Artifact itself (see crate::ConfigurableContractArtifact::source_file()), is only available via the solc CompilerOutput

pub fn with_stripped_file_prefixes(self, base: impl AsRef<Path>) -> Self

Strips the given prefix from all artifact file paths to make them relative to the given base argument

Example

Make all artifact files relative to the project’s root directory

use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let output = project.compile().unwrap().with_stripped_file_prefixes(project.root());

pub fn output(self) -> AggregatedCompilerOutput

Get the (merged) solc compiler output

use std::collections::btree_map::BTreeMap;
use ethers_solc::artifacts::contract::Contract;
use ethers_solc::Project;

let project = Project::builder().build().unwrap();
let contracts: BTreeMap<String, Contract> =
    project.compile().unwrap().output().contracts_into_iter().collect();

pub fn has_compiled_contracts(&self) -> bool

Whether this type has a compiler output

pub fn is_unchanged(&self) -> bool

Whether this type does not contain compiled contracts

pub fn has_compiler_errors(&self) -> bool

Whether there were errors

pub fn has_compiler_warnings(&self) -> bool

Whether there were warnings

pub fn cached_artifacts(&self) -> &Artifacts<T::Artifact>

Returns the set of Artifacts that were cached and got reused during crate::Project::compile()

pub fn compiled_artifacts(&self) -> &Artifacts<T::Artifact>

Returns the set of Artifacts that were compiled with solc in crate::Project::compile()

pub fn compiled_contracts_by_compiler_version(
    &self
) -> BTreeMap<Version, Vec<(String, Contract)>>

Returns a BTreeMap that maps the compiler version used during crate::Project::compile() to a Vector of tuples containing the contract name and the Contract

pub fn find_contract<'a>(
    &self,
    info: impl Into<ContractInfoRef<'a>>
) -> Option<&T::Artifact>

Removes the contract with matching path and name using the <path>:<contractname> pattern where path is optional.

If the path segment is None, then the first matching Contract is returned, see Self::remove_first

Example

use ethers_solc::Project;
use ethers_solc::artifacts::*;
use ethers_solc::info::ContractInfo;

let  output = project.compile().unwrap();
let info = ContractInfo::new("src/Greeter.sol:Greeter");
let contract = output.find_contract(&info).unwrap();

pub fn find(
    &self,
    path: impl AsRef<str>,
    contract: impl AsRef<str>
) -> Option<&T::Artifact>

Finds the artifact with matching path and name

Example

use ethers_solc::Project;
use ethers_solc::artifacts::*;
let output = project.compile().unwrap();
let contract = output.find("src/Greeter.sol", "Greeter").unwrap();

pub fn find_first(&self, contract_name: impl AsRef<str>) -> Option<&T::Artifact>

Finds the first contract with the given name

pub fn remove(
    &mut self,
    path: impl AsRef<str>,
    contract: impl AsRef<str>
) -> Option<T::Artifact>

Finds the artifact with matching path and name

Example

use ethers_solc::Project;
use ethers_solc::artifacts::*;
let output = project.compile().unwrap();
let contract = output.find("src/Greeter.sol", "Greeter").unwrap();

pub fn remove_first(
    &mut self,
    contract_name: impl AsRef<str>
) -> Option<T::Artifact>

Removes the first contract with the given name from the set

Example

use ethers_solc::Project;
use ethers_solc::artifacts::*;
let mut output = project.compile().unwrap();
let contract = output.remove_first("Greeter").unwrap();

pub fn remove_contract<'a>(
    &mut self,
    info: impl Into<ContractInfoRef<'a>>
) -> Option<T::Artifact>

Removes the contract with matching path and name using the <path>:<contractname> pattern where path is optional.

If the path segment is None, then the first matching Contract is returned, see Self::remove_first

Example

use ethers_solc::Project;
use ethers_solc::artifacts::*;
use ethers_solc::info::ContractInfo;
let mut output = project.compile().unwrap();
let info = ContractInfo::new("src/Greeter.sol:Greeter");
let contract = output.remove_contract(&info).unwrap();

impl ProjectCompileOutput<ConfigurableArtifacts>

pub fn into_contract_bytecodes(
    self
) -> impl Iterator<Item = (ArtifactId, CompactContractBytecode)>

A helper functions that extracts the underlying CompactContractBytecode from the crate::ConfigurableContractArtifact

Example

use std::collections::btree_map::BTreeMap;
use ethers_solc::artifacts::contract::CompactContractBytecode;
use ethers_solc::{ArtifactId, Project};
use ethers_solc::contracts::ArtifactContracts;

let project = Project::builder().build().unwrap();
let contracts: ArtifactContracts = project.compile().unwrap().into_contract_bytecodes().collect();

Trait Implementations

impl<T: Clone + ArtifactOutput> Clone for ProjectCompileOutput<T>where
    T::Artifact: Clone,
    T::Artifact: Clone,

fn clone(&self) -> ProjectCompileOutput<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + ArtifactOutput> Debug for ProjectCompileOutput<T>where
    T::Artifact: Debug,
    T::Artifact: Debug,

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

Formats the value using the given formatter.

impl<T: Default + ArtifactOutput> Default for ProjectCompileOutput<T>where
    T::Artifact: Default,
    T::Artifact: Default,

fn default() -> ProjectCompileOutput<T>

Returns the “default value” for a type.

impl<T: ArtifactOutput> Display for ProjectCompileOutput<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + ArtifactOutput> PartialEq<ProjectCompileOutput<T>> for ProjectCompileOutput<T>where
    T::Artifact: PartialEq,
    T::Artifact: PartialEq,

fn eq(&self, other: &ProjectCompileOutput<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: ArtifactOutput> StructuralPartialEq for ProjectCompileOutput<T>