Merge remote-tracking branch 'origin/master' into brock/scripting

Author: joshieDo

Cargo.lock

@@ -72,7 +72,6 @@ similar = { version = "2.1.0", features = ["inline"] }
 strsim = "0.10.0"
 bytes = "1.1.0"
 strum = { version = "0.24", features = ["derive"] }
-reqwest = { version = "0.11.8", default-features = false, features = ["json"] } 
 
 [dev-dependencies]
 anvil = { path = "../anvil" }

cli/Cargo.toml

@@ -43,6 +43,13 @@ use crate::{
     utils::{consume_config_rpc_url, read_secret},
 };
 use eyre::WrapErr;
+use foundry_utils::{
+    format_tokens,
+    selectors::{
+        decode_calldata, decode_event_topic, decode_function_selector, import_selectors,
+        parse_signatures, pretty_calldata, ParsedSignatures, SelectorImportData,
+    },
+};
 
 #[tokio::main]
 async fn main() -> eyre::Result<()> {
@@ -414,12 +421,12 @@ async fn main() -> eyre::Result<()> {
         }
         Subcommands::CalldataDecode { sig, calldata } => {
             let tokens = SimpleCast::abi_decode(&sig, &calldata, true)?;
-            let tokens = foundry_utils::format_tokens(&tokens);
+            let tokens = format_tokens(&tokens);
             tokens.for_each(|t| println!("{t}"));
         }
         Subcommands::AbiDecode { sig, calldata, input } => {
             let tokens = SimpleCast::abi_decode(&sig, &calldata, input)?;
-            let tokens = foundry_utils::format_tokens(&tokens);
+            let tokens = format_tokens(&tokens);
             tokens.for_each(|t| println!("{t}"));
         }
         Subcommands::AbiEncode { sig, args } => {
@@ -430,11 +437,11 @@ async fn main() -> eyre::Result<()> {
             println!("{encoded}");
         }
         Subcommands::FourByte { selector } => {
-            let sigs = foundry_utils::decode_function_selector(&selector).await?;
+            let sigs = decode_function_selector(&selector).await?;
             sigs.iter().for_each(|sig| println!("{}", sig));
         }
         Subcommands::FourByteDecode { calldata } => {
-            let sigs = foundry_utils::decode_calldata(&calldata).await?;
+            let sigs = decode_calldata(&calldata).await?;
             sigs.iter().enumerate().for_each(|(i, sig)| println!("{}) \"{}\"", i + 1, sig));
 
             let sig = match sigs.len() {
@@ -451,21 +458,31 @@ async fn main() -> eyre::Result<()> {
             }?;
 
             let tokens = SimpleCast::abi_decode(sig, &calldata, true)?;
-            let tokens = foundry_utils::format_tokens(&tokens);
+            let tokens = format_tokens(&tokens);
 
             tokens.for_each(|t| println!("{t}"));
         }
         Subcommands::FourByteEvent { topic } => {
-            let sigs = foundry_utils::decode_event_topic(&topic).await?;
+            let sigs = decode_event_topic(&topic).await?;
             sigs.iter().for_each(|sig| println!("{}", sig));
         }
 
+        Subcommands::UploadSignature { signatures } => {
+            let ParsedSignatures { signatures, abis } = parse_signatures(signatures);
+            if !abis.is_empty() {
+                import_selectors(SelectorImportData::Abi(abis)).await?.describe();
+            }
+            if !signatures.is_empty() {
+                import_selectors(SelectorImportData::Raw(signatures)).await?.describe();
+            }
+        }
+
         Subcommands::PrettyCalldata { calldata, offline } => {
             if !calldata.starts_with("0x") {
                 eprintln!("Expected calldata hex string, received \"{calldata}\"");
                 std::process::exit(0)
             }
-            let pretty_data = foundry_utils::pretty_calldata(&calldata, offline).await?;
+            let pretty_data = pretty_calldata(&calldata, offline).await?;
             println!("{pretty_data}");
         }
         Subcommands::Age { block, rpc_url } => {

cli/src/cast.rs

@@ -4,12 +4,8 @@ use crate::{
     opts::forge::CompilerArgs,
 };
 use clap::Parser;
-use ethers::prelude::artifacts::{output_selection::ContractOutputSelection, LosslessAbi};
-use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
-use tracing::trace;
-
-static SELECTOR_DATABASE_URL: &str = "https://sig.eth.samczsun.com/api/v1/import";
+use ethers::prelude::artifacts::output_selection::ContractOutputSelection;
+use foundry_utils::selectors::{import_selectors, SelectorImportData};
 
 #[derive(Debug, Clone, Parser)]
 pub struct UploadSelectorsArgs {
@@ -34,79 +30,21 @@ impl UploadSelectorsArgs {
             ..Default::default()
         };
 
-        trace!("Building project");
         let project = build_args.project()?;
         let outcome = compile::suppress_compile(&project)?;
         let found_artifact = outcome.find(&contract);
         let artifact = found_artifact.ok_or_else(|| {
             eyre::eyre!("Could not find artifact `{contract}` in the compiled artifacts")
         })?;
 
-        let body = ImportRequest {
-            import_type: "abi".to_string(),
-            data: vec![artifact.abi.clone().ok_or(eyre::eyre!("Unable to fetch abi"))?],
-        };
+        let import_data = SelectorImportData::Abi(vec![artifact
+            .abi
+            .clone()
+            .ok_or(eyre::eyre!("Unable to fetch abi"))?]);
 
         // upload abi to selector database
-        trace!("Uploading selector args {:?}", body);
-        let res: ImportResponse = reqwest::Client::new()
-            .post(SELECTOR_DATABASE_URL)
-            .json(&body)
-            .send()
-            .await?
-            .json()
-            .await?;
-        trace!("Got response: {:?}", res);
-        res.describe_upload();
+        import_selectors(import_data).await?.describe();
 
         Ok(())
     }
 }
-
-#[derive(Serialize, Debug)]
-struct ImportRequest {
-    #[serde(rename = "type")]
-    import_type: String,
-    data: Vec<LosslessAbi>,
-}
-
-#[derive(Deserialize, Debug)]
-struct ImportTypeData {
-    imported: HashMap<String, String>,
-    duplicated: HashMap<String, String>,
-}
-
-#[derive(Deserialize, Debug)]
-struct ImportData {
-    function: ImportTypeData,
-    event: ImportTypeData,
-}
-
-#[derive(Deserialize, Debug)]
-struct ImportResponse {
-    result: ImportData,
-}
-
-impl ImportResponse {
-    /// Print info about the functions which were uploaded or already known
-    pub fn describe_upload(&self) {
-        self.result
-            .function
-            .imported
-            .iter()
-            .for_each(|(k, v)| println!("Imported: Function {k}: {v}"));
-        self.result.event.imported.iter().for_each(|(k, v)| println!("Imported: Event {k}: {v}"));
-        self.result
-            .function
-            .duplicated
-            .iter()
-            .for_each(|(k, v)| println!("Duplicated: Function {k}: {v}"));
-        self.result
-            .event
-            .duplicated
-            .iter()
-            .for_each(|(k, v)| println!("Duplicated: Event {k}: {v}"));
-
-        println!("Selectors successfully uploaded to https://sig.eth.samczsun.com");
-    }
-}

cli/src/cmd/forge/fourbyte.rs

@@ -141,6 +141,10 @@ fn install_as_submodule(
     target_dir: &str,
     no_commit: bool,
 ) -> eyre::Result<()> {
+    if !no_commit && !git_status_clean()? {
+        eyre::bail!("There are changes in your working/staging area. Commit them first or add the `--no-commit` option.")
+    }
+
     // install the dep
     git_submodule(dep, libs, target_dir)?;
 
@@ -168,6 +172,21 @@ fn install_as_submodule(
     Ok(())
 }
 
+// check that there are no modification in git working/staging area
+fn git_status_clean() -> eyre::Result<bool> {
+    let output = Command::new("git")
+        .args(&["status", "--short"])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .output()?;
+    if !&output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        eyre::bail!("{}", stderr.trim())
+    }
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    Ok(stdout.trim().is_empty())
+}
+
 fn git_clone(dep: &Dependency, libs: &Path, target_dir: &str) -> eyre::Result<()> {
     let url = dep.url.as_ref().unwrap();
 

cli/src/cmd/forge/install.rs

@@ -424,37 +424,57 @@ Defaults to decoding output data. To decode input data pass --input or use cast
     },
     #[clap(name = "4byte")]
     #[clap(aliases = &["4", "4b"])]
-    #[clap(about = "Get the function signatures for the given selector from 4byte.directory.")]
+    #[clap(
+        about = "Get the function signatures for the given selector from https://sig.eth.samczsun.com."
+    )]
     FourByte {
         #[clap(help = "The function selector.")]
         selector: String,
     },
     #[clap(name = "4byte-decode")]
     #[clap(aliases = &["4d", "4bd"])]
-    #[clap(about = "Decode ABI-encoded calldata using 4byte.directory.")]
+    #[clap(about = "Decode ABI-encoded calldata using https://sig.eth.samczsun.com.")]
     FourByteDecode {
         #[clap(help = "The ABI-encoded calldata.")]
         calldata: String,
     },
     #[clap(name = "4byte-event")]
     #[clap(aliases = &["4e", "4be"])]
-    #[clap(about = "Get the event signature for a given topic 0 from 4byte.directory.")]
+    #[clap(
+        about = "Get the event signature for a given topic 0 from https://sig.eth.samczsun.com."
+    )]
     FourByteEvent {
         #[clap(help = "Topic 0", value_name = "TOPIC_0")]
         topic: String,
     },
+    #[clap(name = "upload-signature")]
+    #[clap(aliases = &["ups"])]
+    #[clap(about = r#"Upload the given signatures to https://sig.eth.samczsun.com.
+
+    Examples:
+    - cast upload-signature "transfer(address,uint256)"
+    - cast upload-signature "function transfer(address,uint256)"
+    - cast upload-signature "function transfer(address,uint256)" "event Transfer(address,address,uint256)"
+    - cast upload-signature ./out/Contract.sol/Contract.json
+    "#)]
+    UploadSignature {
+        #[clap(
+            help = "The signatures to upload. Prefix with 'function', 'event', or 'error'. Defaults to function if no prefix given. Can also take paths to contract artifact JSON."
+        )]
+        signatures: Vec<String>,
+    },
     #[clap(name = "pretty-calldata")]
     #[clap(alias = "pc")]
     #[clap(
         about = "Pretty print calldata.",
         long_about = r#"Pretty print calldata.
 
-Tries to decode the calldata using 4byte.directory unless --offline is passed."#
+Tries to decode the calldata using https://sig.eth.samczsun.com unless --offline is passed."#
     )]
     PrettyCalldata {
         #[clap(help = "The calldata.")]
         calldata: String,
-        #[clap(long, short, help = "Skip the 4byte directory lookup.")]
+        #[clap(long, short, help = "Skip the https://sig.eth.samczsun.com lookup.")]
         offline: bool,
     },
     #[clap(name = "age")]