Struct ethers_core::utils::Solc

pub struct Solc {
    pub solc_path: Option<PathBuf>,
    pub paths: Vec<String>,
    pub optimizer: Option<usize>,
    pub evm_version: EvmVersion,
    pub allowed_paths: Vec<PathBuf>,
    pub args: Vec<String>,
}

Solidity Compiler Bindings

Assumes that solc is installed and available in the caller’s $PATH. Any calls will panic otherwise.

By default, it uses 200 optimizer runs and Istanbul as the EVM version

Examples

use ethers_core::utils::Solc;

// Give it a glob
let contracts = Solc::new("./contracts/*")
    .optimizer(Some(200))
    .build()?;

// this will return None if the specified contract did not exist in the compiled
// files
let contract = contracts.get("SimpleStorage").expect("contract not found");

Fields

solc_path: Option<PathBuf>

The path to the Solc binary

paths: Vec<String>

The path where contracts will be read from

optimizer: Option<usize>

Number of optimizer runs. None for no optimization

evm_version: EvmVersion

Evm Version

allowed_paths: Vec<PathBuf>

Paths for importing other libraries

args: Vec<String>

Additional arguments to pass to solc

Implementations

impl Solc

pub fn new(path: &str) -> Self

Instantiates The Solc builder with the provided glob of Solidity files

pub fn new_with_paths(paths: Vec<String>) -> Self

Instantiates the Solc builder for the provided paths

pub fn build_raw(
    self
) -> Result<HashMap<String, CompiledContractStr>, SolcError>

Gets the ABI for the contracts

pub fn build(self) -> Result<HashMap<String, CompiledContract>, SolcError>

Builds the contracts and returns a hashmap for each named contract

pub fn version(solc_path: Option<PathBuf>) -> String

Returns the output of solc --version

Panics

If solc is not found

pub fn evm_version(self, version: EvmVersion) -> Self

Sets the EVM version for compilation

pub fn solc_path(self, path: PathBuf) -> Self

Sets the path to the solc binary

pub fn optimizer(self, runs: Option<usize>) -> Self

Sets the optimizer runs (default = 200). None indicates no optimization

use ethers_core::utils::Solc;

// No optimization
let contracts = Solc::new("./contracts/*")
    .optimizer(None)
    .build().unwrap();

// Some(200) is default, optimizer on with 200 runs
// .arg() allows passing arbitrary args to solc command
let optimized_contracts = Solc::new("./contracts/*")
    .optimizer(Some(200))
    .arg("--metadata-hash=none")
    .build().unwrap();

pub fn allowed_paths(self, paths: Vec<PathBuf>) -> Self

Sets the allowed paths for using files from outside the same directory

pub fn arg<T: Into<String>>(self, arg: T) -> Self

Adds an argument to pass to solc

pub fn args<I, S>(self, args: I) -> Self where
    I: IntoIterator<Item = S>,
    S: Into<String>, 

Adds multiple arguments to pass to solc