Struct ethers_solc::Solc

pub struct Solc {
    pub solc: PathBuf,
    pub base_path: Option<PathBuf>,
    pub args: Vec<String>,
}

Abstraction over solc command line utility

Supports sync and async functions.

By default the solc path is configured as follows, with descending priority:

1. SOLC_PATH environment variable
2. svm’s global_version (set via svm use <version>), stored at <svm_home>/.global_version
3. solc otherwise

Fields

solc: PathBuf

Path to the solc executable

base_path: Option<PathBuf>

The base path to set when invoking solc, see also https://docs.soliditylang.org/en/v0.8.11/path-resolution.html#base-path-and-include-paths

args: Vec<String>

Additional arguments passed to the solc executable

Implementations

impl Solc

pub fn new(path: impl Into<PathBuf>) -> Self

A new instance which points to solc

pub fn with_base_path(self, base_path: impl Into<PathBuf>) -> Self

Sets solc’s base path

Ref: https://docs.soliditylang.org/en/v0.8.11/path-resolution.html#base-path-and-include-paths

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

Adds an argument to pass to the solc command.

pub fn args<I, S>(self, args: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Adds multiple arguments to pass to the solc.

pub fn svm_home() -> Option<PathBuf>

Available on non-WebAssembly only.

Returns the directory in which svm stores all versions

This will be: ~/.svm on unix, if it exists

• $XDG_DATA_HOME (~/.local/share/svm) if the svm folder does not exist.

pub fn svm_global_version() -> Option<Version>

Available on non-WebAssembly only.

Returns the semver::Version svm’s .global_version is currently set to. global_version is configured with (svm use <version>)

This will read the version string (eg: “0.8.9”) that the ~/.svm/.global_version file contains

pub fn installed_versions() -> Vec<SolcVersion>

Available on non-WebAssembly only.

Returns the list of all solc instances installed at SVM_HOME

pub fn all_versions() -> Vec<SolcVersion>

Available on crate feature svm-solc and non-WebAssembly only.

Returns the list of all versions that are available to download and marking those which are already installed.

pub fn find_svm_installed_version( version: impl AsRef<str> ) -> Result<Option<Self>>

Available on non-WebAssembly only.

Returns the path for a svm installed version.

Example

 use ethers_solc::Solc;
let solc = Solc::find_svm_installed_version("0.8.9").unwrap();
assert_eq!(solc, Some(Solc::new("~/.svm/0.8.9/solc-0.8.9")));

pub fn find_or_install_svm_version(version: impl AsRef<str>) -> Result<Self>

Available on non-WebAssembly and crate feature svm-solc only.

Returns the path for a svm installed version.

If the version is not installed yet, it will install it.

Example

 use ethers_solc::Solc;
let solc = Solc::find_or_install_svm_version("0.8.9").unwrap();
assert_eq!(solc, Solc::new("~/.svm/0.8.9/solc-0.8.9"));

pub fn find_matching_installation( versions: &[Version], required_version: &VersionReq ) -> Option<Version>

Assuming the versions array is sorted, it returns the first element which satisfies the provided VersionReq

pub fn detect_version(source: &Source) -> Result<Version>

Available on crate feature svm-solc and non-WebAssembly only.

Given a Solidity source, it detects the latest compiler version which can be used to build it, and returns it.

If the required compiler version is not installed, it also proceeds to install it.

pub fn ensure_installed(sol_version: &VersionReq) -> Result<Version>

Available on crate feature svm-solc and non-WebAssembly only.

Given a Solidity version requirement, it detects the latest compiler version which can be used to build it, and returns it.

If the required compiler version is not installed, it also proceeds to install it.

pub fn source_version_req(source: &Source) -> Result<VersionReq>

Parses the given source looking for the pragma definition and returns the corresponding SemVer version requirement.

pub fn version_req(version: &str) -> Result<VersionReq>

Returns the corresponding SemVer version requirement for the solidity version.

Note: This is a workaround for the fact that VersionReq::parse does not support whitespace separators and requires comma separated operators. See VersionReq.

pub async fn install(version: &Version) -> Result<Self, SolcVmError>

Available on crate feature svm-solc and non-WebAssembly only.

Installs the provided version of Solc in the machine under the svm dir and returns the Solc instance pointing to the installation.

Example

 use ethers_solc::{Solc, ISTANBUL_SOLC};
 let solc = Solc::install(&ISTANBUL_SOLC).await.unwrap();

pub fn blocking_install(version: &Version) -> Result<Self, SolcVmError>

Available on crate feature svm-solc and non-WebAssembly only.

Blocking version of Self::install

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

Available on crate feature svm-solc and non-WebAssembly only.

Verify that the checksum for this version of solc is correct. We check against the SHA256 checksum from the build information published by binaries.soliditylang.org

pub fn compile_source(&self, path: impl AsRef<Path>) -> Result<CompilerOutput>

Convenience function for compiling all sources under the given path

pub fn compile_exact(&self, input: &CompilerInput) -> Result<CompilerOutput>

Same as Self::compile(), but only returns those files which are included in the CompilerInput.

In other words, this removes those files from the CompilerOutput that are not included in the provided CompilerInput.

Example

 use ethers_solc::{CompilerInput, Solc};
let solc = Solc::default();
let input = CompilerInput::new("./contracts")?[0].clone();
let output = solc.compile_exact(&input)?;

pub fn compile<T: Serialize>(&self, input: &T) -> Result<CompilerOutput>

Run solc --stand-json and return the solc’s output as CompilerOutput

Example

 use ethers_solc::{CompilerInput, Solc};
let solc = Solc::default();
let input = CompilerInput::new("./contracts")?;
let output = solc.compile(&input)?;

pub fn compile_as<T: Serialize, D: DeserializeOwned>( &self, input: &T ) -> Result<D>

Run solc --stand-json and return the solc’s output as the given json output

pub fn compile_output<T: Serialize>(&self, input: &T) -> Result<Vec<u8>>

pub fn version_short(&self) -> Result<Version>

pub fn version(&self) -> Result<Version>

Returns the version from the configured solc

impl Solc

pub async fn async_compile_source( &self, path: impl AsRef<Path> ) -> Result<CompilerOutput>

Available on crate feature async only.

Convenience function for compiling all sources under the given path

pub async fn async_compile<T: Serialize>( &self, input: &T ) -> Result<CompilerOutput>

Available on crate feature async only.

Run solc --stand-json and return the solc’s output as CompilerOutput

pub async fn async_compile_as<T: Serialize, D: DeserializeOwned>( &self, input: &T ) -> Result<D>

Available on crate feature async only.

Run solc --stand-json and return the solc’s output as the given json output

pub async fn async_compile_output<T: Serialize>( &self, input: &T ) -> Result<Vec<u8>>

Available on crate feature async only.

pub async fn async_version(&self) -> Result<Version>

Available on crate feature async only.

pub async fn compile_many<I>(jobs: I, n: usize) -> CompiledMany

where I: IntoIterator<Item = (Solc, CompilerInput)>,

Available on crate feature async only.

Compiles all CompilerInputs with their associated Solc.

This will buffer up to n solc processes and then return the CompilerOutputs in the order in which they complete. No more than n futures will be buffered at any point in time, and less than n may also be buffered depending on the state of each future.

Example

Compile 2 CompilerInputs at once

use ethers_solc::{CompilerInput, Solc};
let solc1 = Solc::default();
let solc2 = Solc::default();
let input1 = CompilerInput::new("contracts").unwrap()[0].clone();
let input2 = CompilerInput::new("src").unwrap()[0].clone();

let outputs = Solc::compile_many([(solc1, input1), (solc2, input2)], 2).await.flattened().unwrap();

Trait Implementations

impl AsRef<Path> for Solc

fn as_ref(&self) -> &Path

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Solc

fn clone(&self) -> Solc

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Solc

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

Formats the value using the given formatter.

impl Default for Solc

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Solc

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Solc

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

Formats the value using the given formatter.

impl<T: Into<PathBuf>> From<T> for Solc

fn from(solc: T) -> Self

Converts to this type from the input type.

impl Ord for Solc

fn cmp(&self, other: &Solc) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Solc

fn eq(&self, other: &Solc) -> 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 PartialOrd for Solc

fn partial_cmp(&self, other: &Solc) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Solc

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Solc

impl StructuralPartialEq for Solc