Use SolidityLang for solc downloads

* Added a resolver tied to a specific block

* Increase the number of private keys

* Increase kitchensink wait time to 60 seconds

* Add a case ignore flag

crates/compiler/src/solc.rs

@@ -238,4 +238,25 @@ mod test {
             Version::new(0, 7, 6)
         )
     }
+
+    #[tokio::test]
+    async fn compiler_version_can_be_obtained1() {
+        // Arrange
+        let args = Arguments::default();
+        println!("Getting compiler path");
+        let path = Solc::get_compiler_executable(&args, Version::new(0, 4, 21))
+            .await
+            .unwrap();
+        println!("Got compiler path");
+        let compiler = Solc::new(path);
+
+        // Act
+        let version = compiler.version();
+
+        // Assert
+        assert_eq!(
+            version.expect("Failed to get version"),
+            Version::new(0, 4, 21)
+        )
+    }
 }

crates/core/src/driver/mod.rs

@@ -5,6 +5,7 @@ use std::marker::PhantomData;
 use std::path::PathBuf;
 
 use alloy::eips::BlockNumberOrTag;
+use alloy::hex;
 use alloy::json_abi::JsonAbi;
 use alloy::network::{Ethereum, TransactionBuilder};
 use alloy::primitives::{BlockNumber, U256};
@@ -242,6 +243,11 @@ where
         ) {
             let value = U256::from_be_slice(output_word);
             self.variables.insert(variable_name.clone(), value);
+            tracing::info!(
+                variable_name,
+                variable_value = hex::encode(value.to_be_bytes::<32>()),
+                "Assigned variable"
+            );
         }
 
         Ok(())

crates/core/src/main.rs

@@ -162,6 +162,20 @@ where
                 Some(false) | None => true,
             },
         )
+        .filter(
+            |(metadata_file_path, _, case_idx, case, _)| match case.ignore {
+                Some(true) => {
+                    tracing::warn!(
+                        metadata_file_path = %metadata_file_path.display(),
+                        case_idx,
+                        case_name = ?case.name,
+                        "Ignoring case"
+                    );
+                    false
+                }
+                Some(false) | None => true,
+            },
+        )
         .collect::<Vec<_>>();
 
     let metadata_case_status = Arc::new(RwLock::new(test_cases.iter().fold(
@@ -463,6 +477,17 @@ where
             }
         };
 
+        tracing::info!(
+            ?library_instance,
+            library_address = ?leader_receipt.contract_address,
+            "Deployed library to leader"
+        );
+        tracing::info!(
+            ?library_instance,
+            library_address = ?follower_receipt.contract_address,
+            "Deployed library to follower"
+        );
+
         let Some(leader_library_address) = leader_receipt.contract_address else {
             tracing::error!("Contract deployment transaction didn't return an address");
             anyhow::bail!("Contract deployment didn't return an address");

crates/format/src/case.rs

@@ -15,6 +15,7 @@ pub struct Case {
     pub inputs: Vec<Input>,
     pub group: Option<String>,
     pub expected: Option<Expected>,
+    pub ignore: Option<bool>,
 }
 
 impl Case {

crates/solc-binaries/src/cache.rs

@@ -11,14 +11,14 @@ use std::{
 
 use tokio::sync::Mutex;
 
-use crate::download::GHDownloader;
+use crate::download::SolcDownloader;
 
 pub const SOLC_CACHE_DIRECTORY: &str = "solc";
 pub(crate) static SOLC_CACHER: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(Default::default);
 
 pub(crate) async fn get_or_download(
     working_directory: &Path,
-    downloader: &GHDownloader,
+    downloader: &SolcDownloader,
 ) -> anyhow::Result<PathBuf> {
     let target_directory = working_directory
         .join(SOLC_CACHE_DIRECTORY)
@@ -38,7 +38,7 @@ pub(crate) async fn get_or_download(
     Ok(target_file)
 }
 
-async fn download_to_file(path: &Path, downloader: &GHDownloader) -> anyhow::Result<()> {
+async fn download_to_file(path: &Path, downloader: &SolcDownloader) -> anyhow::Result<()> {
     tracing::info!("caching file: {}", path.display());
 
     let Ok(file) = File::create_new(path) else {

crates/solc-binaries/src/download.rs

@@ -38,21 +38,21 @@ impl List {
     }
 }
 
-/// Download solc binaries from GitHub releases (IPFS links aren't reliable).
+/// Download solc binaries from the official SolidityLang site
 #[derive(Clone, Debug)]
-pub struct GHDownloader {
+pub struct SolcDownloader {
     pub version: Version,
     pub target: &'static str,
     pub list: &'static str,
 }
 
-impl GHDownloader {
+impl SolcDownloader {
-    pub const BASE_URL: &str = "https://github.com/ethereum/solidity/releases/download";
+    pub const BASE_URL: &str = "https://binaries.soliditylang.org";
 
-    pub const LINUX_NAME: &str = "solc-static-linux";
+    pub const LINUX_NAME: &str = "linux-amd64";
-    pub const MACOSX_NAME: &str = "solc-macos";
+    pub const MACOSX_NAME: &str = "macosx-amd64";
-    pub const WINDOWS_NAME: &str = "solc-windows.exe";
+    pub const WINDOWS_NAME: &str = "windows-amd64";
-    pub const WASM_NAME: &str = "soljson.js";
+    pub const WASM_NAME: &str = "wasm";
 
     async fn new(
         version: impl Into<VersionOrRequirement>,
@@ -102,26 +102,27 @@ impl GHDownloader {
         Self::new(version, Self::WASM_NAME, List::WASM_URL).await
     }
 
-    /// Returns the download link.
-    pub fn url(&self) -> String {
-        format!("{}/v{}/{}", Self::BASE_URL, &self.version, &self.target)
-    }
-
     /// Download the solc binary.
     ///
     /// Errors out if the download fails or the digest of the downloaded file
     /// mismatches the expected digest from the release [List].
     pub async fn download(&self) -> anyhow::Result<Vec<u8>> {
         tracing::info!("downloading solc: {self:?}");
-        let expected_digest = List::download(self.list)
+        let builds = List::download(self.list).await?.builds;
-            .await?
+        let build = builds
-            .builds
             .iter()
             .find(|build| build.version == self.version)
-            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))
+            .ok_or_else(|| anyhow::anyhow!("solc v{} not found builds", self.version))?;
-            .map(|b| b.sha256.strip_prefix("0x").unwrap_or(&b.sha256).to_string())?;
 
-        let file = reqwest::get(self.url()).await?.bytes().await?.to_vec();
+        let path = build.path.clone();
+        let expected_digest = build
+            .sha256
+            .strip_prefix("0x")
+            .unwrap_or(&build.sha256)
+            .to_string();
+        let url = format!("{}/{}/{}", Self::BASE_URL, self.target, path.display());
+
+        let file = reqwest::get(url).await?.bytes().await?.to_vec();
 
         if hex::encode(Sha256::digest(&file)) != expected_digest {
             anyhow::bail!("sha256 mismatch for solc version {}", self.version);
@@ -133,7 +134,7 @@ impl GHDownloader {
 
 #[cfg(test)]
 mod tests {
-    use crate::{download::GHDownloader, list::List};
+    use crate::{download::SolcDownloader, list::List};
 
     #[tokio::test]
     async fn try_get_windows() {
@@ -141,7 +142,7 @@ mod tests {
             .await
             .unwrap()
             .latest_release;
-        GHDownloader::windows(version)
+        SolcDownloader::windows(version)
             .await
             .unwrap()
             .download()
@@ -155,7 +156,7 @@ mod tests {
             .await
             .unwrap()
             .latest_release;
-        GHDownloader::macosx(version)
+        SolcDownloader::macosx(version)
             .await
             .unwrap()
             .download()
@@ -169,7 +170,7 @@ mod tests {
             .await
             .unwrap()
             .latest_release;
-        GHDownloader::linux(version)
+        SolcDownloader::linux(version)
             .await
             .unwrap()
             .download()
@@ -180,7 +181,7 @@ mod tests {
     #[tokio::test]
     async fn try_get_wasm() {
         let version = List::download(List::WASM_URL).await.unwrap().latest_release;
-        GHDownloader::wasm(version)
+        SolcDownloader::wasm(version)
             .await
             .unwrap()
             .download()

crates/solc-binaries/src/lib.rs

@@ -6,7 +6,7 @@
 use std::path::{Path, PathBuf};
 
 use cache::get_or_download;
-use download::GHDownloader;
+use download::SolcDownloader;
 
 use revive_dt_common::types::VersionOrRequirement;
 
@@ -25,13 +25,13 @@ pub async fn download_solc(
     wasm: bool,
 ) -> anyhow::Result<PathBuf> {
     let downloader = if wasm {
-        GHDownloader::wasm(version).await
+        SolcDownloader::wasm(version).await
     } else if cfg!(target_os = "linux") {
-        GHDownloader::linux(version).await
+        SolcDownloader::linux(version).await
     } else if cfg!(target_os = "macos") {
-        GHDownloader::macosx(version).await
+        SolcDownloader::macosx(version).await
     } else if cfg!(target_os = "windows") {
-        GHDownloader::windows(version).await
+        SolcDownloader::windows(version).await
     } else {
         unimplemented!()
     }?;