Attempt to improve the geth tx indexing issue.

We're facing an issue where Geth transaction indexing can sometimes stall
on some of the nodes we're running. The logs show that for all transactions
we always need 1 second of waiting time. However, during certain runs we
sometimes run into an issue with some of the nodes where it seems like
their transaction indexer fails (either at the start or after some amount
of time) which leads us to never get the receipts back from these specific
nodes.

This is not a load issue as it appears like all of the other nodes handle
it just fine. However, it looks like once a node gets into this state it
can not get out of it and its bricked for the entire run.

This commit adds some more command line arguments to the geth command in
hopes of improving this issue.

crates/core/src/driver/mod.rs

@@ -101,12 +101,30 @@ where
             anyhow::bail!("unsupported solc version: {:?}", &mode.solc_version);
         };
 
+        // Note: if the metadata is contained within a solidity file then this is the only file that
+        // we wish to compile since this is a self-contained test. Otherwise, if it's a JSON file
+        // then we need to compile all of the contracts that are in the directory since imports are
+        // allowed in there.
+        let Some(ref metadata_file_path) = metadata.file_path else {
+            anyhow::bail!("The metadata file path is not defined");
+        };
+        let mut files_to_compile = if metadata_file_path
+            .extension()
+            .is_some_and(|extension| extension.eq_ignore_ascii_case("sol"))
+        {
+            Box::new(std::iter::once(metadata_file_path.clone())) as Box<dyn Iterator<Item = _>>
+        } else {
+            Box::new(
+                FilesWithExtensionIterator::new(metadata.directory()?)
+                    .with_allowed_extension("sol"),
+            )
+        };
+
         let compiler = Compiler::<T::Compiler>::new()
             .allow_path(metadata.directory()?)
             .solc_optimizer(mode.solc_optimize());
-        let mut compiler = FilesWithExtensionIterator::new(metadata.directory()?)
-            .with_allowed_extension("sol")
-            .try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
+        let mut compiler =
+            files_to_compile.try_fold(compiler, |compiler, path| compiler.with_source(&path))?;
         for (library_instance, (library_address, _)) in self.deployed_libraries.iter() {
             let library_ident = &metadata
                 .contracts

crates/format/src/corpus.rs

@@ -35,33 +35,47 @@ impl Corpus {
 ///
 /// `path` is expected to be a directory.
 pub fn collect_metadata(path: &Path, tests: &mut Vec<MetadataFile>) {
-    let dir_entry = match std::fs::read_dir(path) {
-        Ok(dir_entry) => dir_entry,
-        Err(error) => {
-            tracing::error!("failed to read dir '{}': {error}", path.display());
-            return;
-        }
-    };
-
-    for entry in dir_entry {
-        let entry = match entry {
-            Ok(entry) => entry,
+    if path.is_dir() {
+        let dir_entry = match std::fs::read_dir(path) {
+            Ok(dir_entry) => dir_entry,
             Err(error) => {
-                tracing::error!("error reading dir entry: {error}");
-                continue;
+                tracing::error!("failed to read dir '{}': {error}", path.display());
+                return;
             }
         };
 
-        let path = entry.path();
-        if path.is_dir() {
-            collect_metadata(&path, tests);
-            continue;
-        }
+        for entry in dir_entry {
+            let entry = match entry {
+                Ok(entry) => entry,
+                Err(error) => {
+                    tracing::error!("error reading dir entry: {error}");
+                    continue;
+                }
+            };
 
-        if path.is_file() {
-            if let Some(metadata) = MetadataFile::try_from_file(&path) {
+            let path = entry.path();
+            if path.is_dir() {
+                collect_metadata(&path, tests);
+                continue;
+            }
+
+            if path.is_file() {
+                if let Some(metadata) = MetadataFile::try_from_file(&path) {
+                    tests.push(metadata)
+                }
+            }
+        }
+    } else {
+        let Some(extension) = path.extension() else {
+            tracing::error!("Failed to get file extension");
+            return;
+        };
+        if extension.eq_ignore_ascii_case("sol") || extension.eq_ignore_ascii_case("json") {
+            if let Some(metadata) = MetadataFile::try_from_file(path) {
                 tests.push(metadata)
             }
+        } else {
+            tracing::error!(?extension, "Unsupported file extension");
         }
     }
 }

crates/format/src/metadata.rs

@@ -193,7 +193,7 @@ impl Metadata {
                 metadata.file_path = Some(path.to_path_buf());
                 metadata.contracts = Some(
                     [(
-                        ContractInstance::new("test"),
+                        ContractInstance::new("Test"),
                         ContractPathAndIdent {
                             contract_source_path: path.to_path_buf(),
                             contract_ident: ContractIdent::new("Test"),

crates/node/src/geth.rs

@@ -152,6 +152,10 @@ impl Instance {
             .arg("--nodiscover")
             .arg("--maxpeers")
             .arg("0")
+            .arg("--txlookuplimit")
+            .arg("0")
+            .arg("--cache.blocklogs")
+            .arg("512")
             .stderr(stderr_logs_file.try_clone()?)
             .stdout(stdout_logs_file.try_clone()?)
             .spawn()?
@@ -294,7 +298,10 @@ impl EthereumNode for Instance {
                 }
 
                 match provider.get_transaction_receipt(*transaction_hash).await {
-                    Ok(Some(receipt)) => break Ok(receipt),
+                    Ok(Some(receipt)) => {
+                        tracing::info!(?total_wait_duration, "Found receipt");
+                        break Ok(receipt);
+                    }
                     Ok(None) => {}
                     Err(error) => {
                         let error_string = error.to_string();