feat(libs/solc-wrapper): added forge-wrapper and ast extraction

Author: 0xSwapFeeder

libs/solc-wrapper/Cargo.lock

@@ -0,0 +1,11 @@
+[package]
+name = "solc-wrapper"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serde_json = "1.0.113"
+solc-ast-rs-types = "0.1.6"
+thiserror = "1.0.56"

libs/solc-wrapper/Cargo.toml

@@ -0,0 +1,17 @@
+use thiserror::Error;
+
+use crate::forge::error::CommandError;
+
+#[derive(Error, Debug)]
+pub enum SolcWrapperError {
+    #[error("Solc error: {0}")]
+    Solc(#[from] CommandError),
+    #[error("JSON parsing error: {0}")]
+    Json(#[from] serde_json::Error),
+    #[error("No build info produced by foundry")]
+    NoBuildInfo,
+    #[error("Cannot read build info file")]
+    ReadBuildInfo(#[from] std::io::Error),
+    #[error("Cannot read source file")]
+    ReadSourceFile(std::io::Error)
+}

libs/solc-wrapper/src/error.rs

@@ -0,0 +1,62 @@
+use std::process::Command;
+use std::process::Stdio;
+use std::path::PathBuf;
+
+use super::error::{CommandError, CommandType};
+
+pub struct ForgeCommand {
+    args: Vec<String>,
+    bin_path : PathBuf,
+    current_dir: String
+}
+
+impl Default for ForgeCommand {
+    fn default() -> Self {
+        ForgeCommand::new("forge")
+    }
+}
+
+impl ForgeCommand {
+
+    pub fn new(path: impl Into<PathBuf>) -> Self {
+        ForgeCommand {
+            args: Vec::new(),
+            bin_path: path.into(),
+            current_dir: String::from(".")
+        }
+    }
+
+    pub fn current_dir(mut self, current_dir: String) -> Self {
+        self.current_dir = current_dir;
+        self
+    }
+
+    pub fn arg<T: Into<String>>(mut self, arg: T) -> Self {
+        self.args.push(arg.into());
+        self
+    }
+
+    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
+    }
+
+    pub fn execute(&self) -> Result<(), CommandError> {
+        Command::new(&self.bin_path)
+            .current_dir(&self.current_dir)
+            .args(&self.args)
+            .stdout(Stdio::piped())
+            .output()
+            .map_err(|e| {
+                eprintln!("Forge Command Error: {}", e.to_string());
+                CommandError { error: e.to_string(), command_type: CommandType::ParseFile }
+        })?;
+        Ok(())
+    }
+}

libs/solc-wrapper/src/forge/command.rs

@@ -0,0 +1,19 @@
+use thiserror::Error;
+
+#[derive(Debug)]
+pub enum CommandType {
+    ParseFile,
+    ParseStdin,
+}
+
+#[derive(Error, Debug)]
+pub struct CommandError {
+    pub command_type: CommandType,
+    pub error: String,
+}
+
+impl std::fmt::Display for CommandError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "CommandError: {}", self.error)
+    }
+}

libs/solc-wrapper/src/forge/error.rs

@@ -0,0 +1,3 @@
+pub mod error;
+pub mod command;
+pub mod parsing_error;

libs/solc-wrapper/src/forge/mod.rs

@@ -0,0 +1,29 @@
+use thiserror::Error;
+
+
+
+#[derive(Error, Debug)]
+pub struct ErrorLocation {
+    pub file: String,
+    pub line: usize,
+    pub column: usize,
+    pub length: usize
+}
+
+#[derive(Error, Debug)]
+pub struct ParsingError {
+    pub error: String,
+    pub location: ErrorLocation,
+}
+
+impl std::fmt::Display for ErrorLocation {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "ErrorLocation in {} at line {}, column {}", self.file, self.line, self.column)
+    }
+}
+
+impl std::fmt::Display for ParsingError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "ParsingError: {}", self.error)
+    }
+}