Struct ethers_solc::Solc

pub struct Solc {
    pub solc: 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

args: Vec<String>

Additional arguments passed to the solc exectuable

Implementations

impl Solc

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

A new instance which points to solc

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>

Returns the directory in which svm stores all versions

This will be ~/.svm on unix

pub fn svm_global_version() -> Option<Version>

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 find_svm_installed_version(
    version: impl AsRef<str>
) -> Result<Option<Self>>

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_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>

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>

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 version_req(source: &Source) -> Result<VersionReq>

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

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

Installs the provided version of Solc in the machine under the svm dir

Example

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

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

Blocking version of Self::install

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

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

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

Convenience function for compiling all sources under the given path

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<T: Serialize>(
    &self,
    path: impl AsRef<Path>
) -> Result<CompilerOutput>

Convenience function for compiling all sources under the given path

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

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>

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>>

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

pub async fn compile_many<I>(jobs: I, n: usize) -> CompiledMany where
    I: IntoIterator<Item = (Solc, CompilerInput)>, 

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();
let input2 = CompilerInput::new("src").unwrap();

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

Performs the conversion.

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<T: Into<PathBuf>> From<T> for Solc

fn from(solc: T) -> Self

Performs the conversion.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl PartialEq<Solc> 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: &Solc) -> bool

This method tests for !=.

impl PartialOrd<Solc> 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 Eq for Solc

impl StructuralEq for Solc

impl StructuralPartialEq for Solc