use crate::{
artifacts::Source,
error::{Result, SolcError},
utils, CompilerInput, CompilerOutput,
};
use once_cell::sync::Lazy;
use semver::{Version, VersionReq};
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use std::{
fmt,
path::{Path, PathBuf},
process::{Command, Output, Stdio},
str::FromStr,
};
pub mod many;
pub mod output;
pub use output::{contracts, info, sources};
pub mod project;
pub const SOLC: &str = "solc";
pub const BYZANTIUM_SOLC: Version = Version::new(0, 4, 21);
pub const CONSTANTINOPLE_SOLC: Version = Version::new(0, 4, 22);
pub const PETERSBURG_SOLC: Version = Version::new(0, 5, 5);
pub const ISTANBUL_SOLC: Version = Version::new(0, 5, 14);
pub const BERLIN_SOLC: Version = Version::new(0, 8, 5);
pub const LONDON_SOLC: Version = Version::new(0, 8, 7);
pub const PARIS_SOLC: Version = Version::new(0, 8, 18);
pub const SHANGHAI_SOLC: Version = Version::new(0, 8, 20);
pub static SUPPORTS_BASE_PATH: Lazy<VersionReq> =
Lazy::new(|| VersionReq::parse(">=0.6.9").unwrap());
pub static SUPPORTS_INCLUDE_PATH: Lazy<VersionReq> =
Lazy::new(|| VersionReq::parse(">=0.8.8").unwrap());
#[cfg(any(test, feature = "tests"))]
use std::sync::Mutex;
#[cfg(any(test, feature = "tests"))]
#[allow(unused)]
static LOCK: Lazy<Mutex<()>> = Lazy::new(|| Mutex::new(()));
#[cfg(any(test, feature = "tests"))]
#[allow(unused)]
pub(crate) fn take_solc_installer_lock() -> std::sync::MutexGuard<'static, ()> {
LOCK.lock().unwrap()
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub static RELEASES: Lazy<(svm::Releases, Vec<Version>, bool)> =
Lazy::new(|| match serde_json::from_str::<svm::Releases>(svm_builds::RELEASE_LIST_JSON) {
Ok(releases) => {
let sorted_versions = releases.clone().into_versions();
(releases, sorted_versions, true)
}
Err(err) => {
tracing::error!("{:?}", err);
Default::default()
}
});
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SolcVersion {
Installed(Version),
Remote(Version),
}
impl SolcVersion {
pub fn is_installed(&self) -> bool {
matches!(self, SolcVersion::Installed(_))
}
}
impl AsRef<Version> for SolcVersion {
fn as_ref(&self) -> &Version {
match self {
SolcVersion::Installed(v) | SolcVersion::Remote(v) => v,
}
}
}
impl From<SolcVersion> for Version {
fn from(s: SolcVersion) -> Version {
match s {
SolcVersion::Installed(v) | SolcVersion::Remote(v) => v,
}
}
}
impl fmt::Display for SolcVersion {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.as_ref())
}
}
#[derive(Debug, Clone, Eq, PartialEq, PartialOrd, Ord, Serialize, Deserialize)]
pub struct Solc {
pub solc: PathBuf,
pub base_path: Option<PathBuf>,
pub args: Vec<String>,
}
impl Default for Solc {
fn default() -> Self {
if let Ok(solc) = std::env::var("SOLC_PATH") {
return Solc::new(solc)
}
#[cfg(not(target_arch = "wasm32"))]
{
if let Some(solc) = Solc::svm_global_version()
.and_then(|vers| Solc::find_svm_installed_version(vers.to_string()).ok())
.flatten()
{
return solc
}
}
Solc::new(SOLC)
}
}
impl fmt::Display for Solc {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "{}", self.solc.display())?;
if !self.args.is_empty() {
write!(f, " {}", self.args.join(" "))?;
}
Ok(())
}
}
impl Solc {
pub fn new(path: impl Into<PathBuf>) -> Self {
Solc { solc: path.into(), base_path: None, args: Vec::new() }
}
pub fn with_base_path(mut self, base_path: impl Into<PathBuf>) -> Self {
self.base_path = Some(base_path.into());
self
}
#[must_use]
pub fn arg<T: Into<String>>(mut self, arg: T) -> Self {
self.args.push(arg.into());
self
}
#[must_use]
pub fn args<I, S>(mut self, args: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
for arg in args {
self = self.arg(arg);
}
self
}
#[cfg(not(target_arch = "wasm32"))]
pub fn svm_home() -> Option<PathBuf> {
match home::home_dir().map(|dir| dir.join(".svm")) {
Some(dir) => {
if !dir.exists() {
dirs::data_dir().map(|dir| dir.join("svm"))
} else {
Some(dir)
}
}
None => dirs::data_dir().map(|dir| dir.join("svm")),
}
}
#[cfg(not(target_arch = "wasm32"))]
pub fn svm_global_version() -> Option<Version> {
let home = Self::svm_home()?;
let version = std::fs::read_to_string(home.join(".global_version")).ok()?;
Version::parse(&version).ok()
}
#[cfg(not(target_arch = "wasm32"))]
pub fn installed_versions() -> Vec<SolcVersion> {
Self::svm_home()
.map(|home| {
utils::installed_versions(home)
.unwrap_or_default()
.into_iter()
.map(SolcVersion::Installed)
.collect()
})
.unwrap_or_default()
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub fn all_versions() -> Vec<SolcVersion> {
let mut all_versions = Self::installed_versions();
let mut uniques = all_versions
.iter()
.map(|v| {
let v = v.as_ref();
(v.major, v.minor, v.patch)
})
.collect::<std::collections::HashSet<_>>();
all_versions.extend(
RELEASES
.1
.clone()
.into_iter()
.filter(|v| uniques.insert((v.major, v.minor, v.patch)))
.map(SolcVersion::Remote),
);
all_versions.sort_unstable();
all_versions
}
#[cfg(not(target_arch = "wasm32"))]
pub fn find_svm_installed_version(version: impl AsRef<str>) -> Result<Option<Self>> {
let version = version.as_ref();
let solc = Self::svm_home()
.ok_or_else(|| SolcError::msg("svm home dir not found"))?
.join(version)
.join(format!("solc-{version}"));
if !solc.is_file() {
return Ok(None)
}
Ok(Some(Solc::new(solc)))
}
#[cfg(all(not(target_arch = "wasm32"), feature = "svm-solc"))]
pub fn find_or_install_svm_version(version: impl AsRef<str>) -> Result<Self> {
let version = version.as_ref();
if let Some(solc) = Solc::find_svm_installed_version(version)? {
Ok(solc)
} else {
Ok(Solc::blocking_install(&version.parse::<Version>()?)?)
}
}
pub fn find_matching_installation(
versions: &[Version],
required_version: &VersionReq,
) -> Option<Version> {
versions.iter().rev().find(|version| required_version.matches(version)).cloned()
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub fn detect_version(source: &Source) -> Result<Version> {
let sol_version = Self::source_version_req(source)?;
Self::ensure_installed(&sol_version)
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub fn ensure_installed(sol_version: &VersionReq) -> Result<Version> {
#[cfg(any(test, feature = "tests"))]
let _lock = take_solc_installer_lock();
let versions = utils::installed_versions(svm::SVM_DATA_DIR.as_path()).unwrap_or_default();
let local_versions = Self::find_matching_installation(&versions, sol_version);
let remote_versions = Self::find_matching_installation(&RELEASES.1, sol_version);
Ok(match (local_versions, remote_versions) {
(Some(local), None) => local,
(Some(local), Some(remote)) => {
if remote > local {
Self::blocking_install(&remote)?;
remote
} else {
local
}
}
(None, Some(version)) => {
Self::blocking_install(&version)?;
version
}
_ => return Err(SolcError::VersionNotFound),
})
}
pub fn source_version_req(source: &Source) -> Result<VersionReq> {
let version =
utils::find_version_pragma(&source.content).ok_or(SolcError::PragmaNotFound)?;
Self::version_req(version.as_str())
}
pub fn version_req(version: &str) -> Result<VersionReq> {
let version = version.replace(' ', ",");
let exact = !matches!(&version[0..1], "*" | "^" | "=" | ">" | "<" | "~");
let mut version = VersionReq::parse(&version)?;
if exact {
version.comparators[0].op = semver::Op::Exact;
}
Ok(version)
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub async fn install(version: &Version) -> std::result::Result<Self, svm::SolcVmError> {
tracing::trace!("installing solc version \"{}\"", version);
crate::report::solc_installation_start(version);
let result = svm::install(version).await;
crate::report::solc_installation_success(version);
result.map(Solc::new)
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub fn blocking_install(version: &Version) -> std::result::Result<Self, svm::SolcVmError> {
use crate::utils::RuntimeOrHandle;
tracing::trace!("blocking installing solc version \"{}\"", version);
crate::report::solc_installation_start(version);
cfg_if::cfg_if! {
if #[cfg(target_arch = "wasm32")] {
let installation = svm::blocking_install(version);
} else {
let installation = RuntimeOrHandle::new().block_on(svm::install(version));
}
};
match installation {
Ok(path) => {
crate::report::solc_installation_success(version);
Ok(Solc::new(path))
}
Err(err) => {
crate::report::solc_installation_error(version, &err.to_string());
Err(err)
}
}
}
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
pub fn verify_checksum(&self) -> Result<()> {
let version = self.version_short()?;
let mut version_path = svm::version_path(version.to_string().as_str());
version_path.push(format!("solc-{}", version.to_string().as_str()));
tracing::trace!(target:"solc", "reading solc binary for checksum {:?}", version_path);
let content =
std::fs::read(&version_path).map_err(|err| SolcError::io(err, version_path.clone()))?;
if !RELEASES.2 {
return Ok(())
}
#[cfg(windows)]
{
const V0_7_2: Version = Version::new(0, 7, 2);
if version < V0_7_2 {
return Ok(())
}
}
use sha2::Digest;
let mut hasher = sha2::Sha256::new();
hasher.update(content);
let checksum_calc = &hasher.finalize()[..];
let checksum_found = &RELEASES
.0
.get_checksum(&version)
.ok_or_else(|| SolcError::ChecksumNotFound { version: version.clone() })?;
if checksum_calc == checksum_found {
Ok(())
} else {
let expected = hex::encode(checksum_found);
let detected = hex::encode(checksum_calc);
tracing:: warn!(target : "solc", "checksum mismatch for {:?}, expected {}, but found {} for file {:?}", version, expected, detected, version_path);
Err(SolcError::ChecksumMismatch { version, expected, detected, file: version_path })
}
}
pub fn compile_source(&self, path: impl AsRef<Path>) -> Result<CompilerOutput> {
let path = path.as_ref();
let mut res: CompilerOutput = Default::default();
for input in CompilerInput::new(path)? {
let output = self.compile(&input)?;
res.merge(output)
}
Ok(res)
}
pub fn compile_exact(&self, input: &CompilerInput) -> Result<CompilerOutput> {
let mut out = self.compile(input)?;
out.retain_files(input.sources.keys().filter_map(|p| p.to_str()));
Ok(out)
}
pub fn compile<T: Serialize>(&self, input: &T) -> Result<CompilerOutput> {
self.compile_as(input)
}
pub fn compile_as<T: Serialize, D: DeserializeOwned>(&self, input: &T) -> Result<D> {
let output = self.compile_output(input)?;
Ok(serde_json::from_slice(&output)?)
}
pub fn compile_output<T: Serialize>(&self, input: &T) -> Result<Vec<u8>> {
let mut cmd = Command::new(&self.solc);
if let Some(ref base_path) = self.base_path {
cmd.current_dir(base_path);
cmd.arg("--base-path").arg(base_path);
}
let mut child = cmd
.args(&self.args)
.arg("--standard-json")
.stdin(Stdio::piped())
.stderr(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
.map_err(|err| SolcError::io(err, &self.solc))?;
let stdin = child.stdin.take().expect("Stdin exists.");
serde_json::to_writer(stdin, input)?;
compile_output(child.wait_with_output().map_err(|err| SolcError::io(err, &self.solc))?)
}
pub fn version_short(&self) -> Result<Version> {
let version = self.version()?;
Ok(Version::new(version.major, version.minor, version.patch))
}
pub fn version(&self) -> Result<Version> {
version_from_output(
Command::new(&self.solc)
.arg("--version")
.stdin(Stdio::piped())
.stderr(Stdio::piped())
.stdout(Stdio::piped())
.output()
.map_err(|err| SolcError::io(err, &self.solc))?,
)
}
}
#[cfg(feature = "async")]
impl Solc {
pub async fn async_compile_source(&self, path: impl AsRef<Path>) -> Result<CompilerOutput> {
self.async_compile(&CompilerInput::with_sources(Source::async_read_all_from(path).await?))
.await
}
pub async fn async_compile<T: Serialize>(&self, input: &T) -> Result<CompilerOutput> {
self.async_compile_as(input).await
}
pub async fn async_compile_as<T: Serialize, D: DeserializeOwned>(
&self,
input: &T,
) -> Result<D> {
let output = self.async_compile_output(input).await?;
Ok(serde_json::from_slice(&output)?)
}
pub async fn async_compile_output<T: Serialize>(&self, input: &T) -> Result<Vec<u8>> {
use tokio::io::AsyncWriteExt;
let content = serde_json::to_vec(input)?;
let mut cmd = tokio::process::Command::new(&self.solc);
if let Some(ref base_path) = self.base_path {
cmd.current_dir(base_path);
}
let mut child = cmd
.args(&self.args)
.arg("--standard-json")
.stdin(Stdio::piped())
.stderr(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
.map_err(|err| SolcError::io(err, &self.solc))?;
let stdin = child.stdin.as_mut().unwrap();
stdin.write_all(&content).await.map_err(|err| SolcError::io(err, &self.solc))?;
stdin.flush().await.map_err(|err| SolcError::io(err, &self.solc))?;
compile_output(
child.wait_with_output().await.map_err(|err| SolcError::io(err, &self.solc))?,
)
}
pub async fn async_version(&self) -> Result<Version> {
version_from_output(
tokio::process::Command::new(&self.solc)
.arg("--version")
.stdin(Stdio::piped())
.stderr(Stdio::piped())
.stdout(Stdio::piped())
.spawn()
.map_err(|err| SolcError::io(err, &self.solc))?
.wait_with_output()
.await
.map_err(|err| SolcError::io(err, &self.solc))?,
)
}
pub async fn compile_many<I>(jobs: I, n: usize) -> crate::many::CompiledMany
where
I: IntoIterator<Item = (Solc, CompilerInput)>,
{
use futures_util::stream::StreamExt;
let outputs = futures_util::stream::iter(
jobs.into_iter()
.map(|(solc, input)| async { (solc.async_compile(&input).await, solc, input) }),
)
.buffer_unordered(n)
.collect::<Vec<_>>()
.await;
crate::many::CompiledMany::new(outputs)
}
}
fn compile_output(output: Output) -> Result<Vec<u8>> {
if output.status.success() {
Ok(output.stdout)
} else {
Err(SolcError::solc_output(&output))
}
}
fn version_from_output(output: Output) -> Result<Version> {
if output.status.success() {
let stdout = String::from_utf8_lossy(&output.stdout);
let version = stdout
.lines()
.filter(|l| !l.trim().is_empty())
.last()
.ok_or_else(|| SolcError::msg("Version not found in Solc output"))?;
Ok(Version::from_str(&version.trim_start_matches("Version: ").replace(".g++", ".gcc"))?)
} else {
Err(SolcError::solc_output(&output))
}
}
impl AsRef<Path> for Solc {
fn as_ref(&self) -> &Path {
&self.solc
}
}
impl<T: Into<PathBuf>> From<T> for Solc {
fn from(solc: T) -> Self {
Solc::new(solc.into())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::Artifact;
#[test]
fn test_version_parse() {
let req = Solc::version_req(">=0.6.2 <0.8.21").unwrap();
let semver_req: VersionReq = ">=0.6.2,<0.8.21".parse().unwrap();
assert_eq!(req, semver_req);
}
fn solc() -> Solc {
Solc::default()
}
#[test]
fn solc_version_works() {
solc().version().unwrap();
}
#[test]
fn can_parse_version_metadata() {
let _version = Version::from_str("0.6.6+commit.6c089d02.Linux.gcc").unwrap();
}
#[cfg(feature = "async")]
#[tokio::test]
async fn async_solc_version_works() {
let _version = solc().async_version().await.unwrap();
}
#[test]
fn solc_compile_works() {
let input = include_str!("../../test-data/in/compiler-in-1.json");
let input: CompilerInput = serde_json::from_str(input).unwrap();
let out = solc().compile(&input).unwrap();
let other = solc().compile(&serde_json::json!(input)).unwrap();
assert_eq!(out, other);
}
#[test]
fn solc_metadata_works() {
let input = include_str!("../../test-data/in/compiler-in-1.json");
let mut input: CompilerInput = serde_json::from_str(input).unwrap();
input.settings.push_output_selection("metadata");
let out = solc().compile(&input).unwrap();
for (_, c) in out.split().1.contracts_iter() {
assert!(c.metadata.is_some());
}
}
#[test]
fn can_compile_with_remapped_links() {
let input: CompilerInput =
serde_json::from_str(include_str!("../../test-data/library-remapping-in.json"))
.unwrap();
let out = solc().compile(&input).unwrap();
let (_, mut contracts) = out.split();
let contract = contracts.remove("LinkTest").unwrap();
let bytecode = &contract.get_bytecode().unwrap().object;
assert!(!bytecode.is_unlinked());
}
#[test]
fn can_compile_with_remapped_links_temp_dir() {
let input: CompilerInput =
serde_json::from_str(include_str!("../../test-data/library-remapping-in-2.json"))
.unwrap();
let out = solc().compile(&input).unwrap();
let (_, mut contracts) = out.split();
let contract = contracts.remove("LinkTest").unwrap();
let bytecode = &contract.get_bytecode().unwrap().object;
assert!(!bytecode.is_unlinked());
}
#[cfg(feature = "async")]
#[tokio::test]
async fn async_solc_compile_works() {
let input = include_str!("../../test-data/in/compiler-in-1.json");
let input: CompilerInput = serde_json::from_str(input).unwrap();
let out = solc().async_compile(&input).await.unwrap();
let other = solc().async_compile(&serde_json::json!(input)).await.unwrap();
assert_eq!(out, other);
}
#[cfg(feature = "async")]
#[tokio::test]
async fn async_solc_compile_works2() {
let input = include_str!("../../test-data/in/compiler-in-2.json");
let input: CompilerInput = serde_json::from_str(input).unwrap();
let out = solc().async_compile(&input).await.unwrap();
let other = solc().async_compile(&serde_json::json!(input)).await.unwrap();
assert_eq!(out, other);
let sync_out = solc().compile(&input).unwrap();
assert_eq!(out, sync_out);
}
#[test]
fn test_version_req() {
let versions = ["=0.1.2", "^0.5.6", ">=0.7.1", ">0.8.0"];
let sources = versions.iter().map(|version| source(version));
sources.zip(versions).for_each(|(source, version)| {
let version_req = Solc::source_version_req(&source).unwrap();
assert_eq!(version_req, VersionReq::from_str(version).unwrap());
});
let version_range = ">=0.8.0 <0.9.0";
let source = source(version_range);
let version_req = Solc::source_version_req(&source).unwrap();
assert_eq!(version_req, VersionReq::from_str(">=0.8.0,<0.9.0").unwrap());
}
#[test]
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
fn test_detect_version() {
for (pragma, expected) in [
("=0.4.14", "0.4.14"),
("0.4.14", "0.4.14"),
("^0.4.14", "0.4.26"),
(">=0.4.0 <0.5.0", "0.4.26"),
(">=0.5.0", "0.8.24"),
] {
let source = source(pragma);
let res = Solc::detect_version(&source).unwrap();
assert_eq!(res, Version::from_str(expected).unwrap());
}
}
#[test]
#[cfg(feature = "full")]
fn test_find_installed_version_path() {
let _lock = LOCK.lock();
let ver = "0.8.6";
let version = Version::from_str(ver).unwrap();
if utils::installed_versions(svm::SVM_DATA_DIR.as_path())
.map(|versions| !versions.contains(&version))
.unwrap_or_default()
{
Solc::blocking_install(&version).unwrap();
}
let res = Solc::find_svm_installed_version(version.to_string()).unwrap().unwrap();
let expected = svm::SVM_DATA_DIR.join(ver).join(format!("solc-{ver}"));
assert_eq!(res.solc, expected);
}
#[test]
#[cfg(all(feature = "svm-solc", not(target_arch = "wasm32")))]
fn can_install_solc_in_tokio_rt() {
let version = Version::from_str("0.8.6").unwrap();
let rt = tokio::runtime::Runtime::new().unwrap();
let result = rt.block_on(async { Solc::blocking_install(&version) });
assert!(result.is_ok());
}
#[test]
fn does_not_find_not_installed_version() {
let ver = "1.1.1";
let version = Version::from_str(ver).unwrap();
let res = Solc::find_svm_installed_version(version.to_string()).unwrap();
assert!(res.is_none());
}
#[test]
fn test_find_latest_matching_installation() {
let versions = ["0.4.24", "0.5.1", "0.5.2"]
.iter()
.map(|version| Version::from_str(version).unwrap())
.collect::<Vec<_>>();
let required = VersionReq::from_str(">=0.4.24").unwrap();
let got = Solc::find_matching_installation(&versions, &required).unwrap();
assert_eq!(got, versions[2]);
}
#[test]
fn test_no_matching_installation() {
let versions = ["0.4.24", "0.5.1", "0.5.2"]
.iter()
.map(|version| Version::from_str(version).unwrap())
.collect::<Vec<_>>();
let required = VersionReq::from_str(">=0.6.0").unwrap();
let got = Solc::find_matching_installation(&versions, &required);
assert!(got.is_none());
}
fn source(version: &str) -> Source {
Source::new(format!("pragma solidity {version};\n"))
}
}