chore: deprecate signature uploading

onbjerg · onbjerg · commit 7755e98484f5 · 2025-09-29T22:53:41.000+02:00
diff --git a/crates/cast/src/args.rs b/crates/cast/src/args.rs
@@ -19,9 +19,8 @@ use foundry_common::{
     fmt::{format_tokens, format_uint_exp, serialize_value_as_json},
     fs,
     selectors::{
-        ParsedSignatures, SelectorImportData, SelectorKind, decode_calldata, decode_event_topic,
-        decode_function_selector, decode_selectors, import_selectors, parse_signatures,
-        pretty_calldata,
+        SelectorKind, decode_calldata, decode_event_topic, decode_function_selector,
+        decode_selectors, pretty_calldata,
     },
     shell, stdin,
 };
@@ -594,15 +593,13 @@ pub async fn run_command(args: CastArgs) -> Result<()> {
                 sh_println!("{sig}")?
             }
         }
-        CastSubcommand::UploadSignature { signatures } => {
-            let signatures = stdin::unwrap_vec(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();
-            }
+        CastSubcommand::UploadSignature { .. } => {
+            sh_eprintln!(
+                "Selector uploading is deprecated and is currently a no-op, as the upstream API has been removed."
+            )?;
+            sh_eprintln!(
+                "To upload selectors in the future, verify your contracts with Sourcify."
+            )?;
         }
 
         // ENS
diff --git a/crates/cast/src/opts.rs b/crates/cast/src/opts.rs
@@ -742,7 +742,7 @@ pub enum CastSubcommand {
         topic: Option<B256>,
     },
 
-    /// Upload the given signatures to <https://docs.sourcify.dev/docs/api/>.
+    /// DEPRECATED: Upload the given signatures to <https://docs.sourcify.dev/docs/api/>.
     ///
     /// Example inputs:
     /// - "transfer(address,uint256)"
diff --git a/crates/cast/tests/cli/selectors.rs b/crates/cast/tests/cli/selectors.rs
@@ -14,6 +14,7 @@ ValueTooHigh(uint256,uint256)
 casttest!(fourbyte, |_prj, cmd| {
     cmd.args(["4byte", "0xa9059cbb"]).assert_success().stdout_eq(str![[r#"
 transfer(address,uint256)
+_____$_$__$___$$$___$$___$__$$(address,uint256)
 
 "#]]);
 });
@@ -39,6 +40,7 @@ casttest!(fourbyte_calldata, |_prj, cmd| {
 casttest!(fourbyte_calldata_only_selector, |_prj, cmd| {
     cmd.args(["4byte-calldata", "0xa9059cbb"]).assert_success().stdout_eq(str![[r#"
 transfer(address,uint256)
+_____$_$__$___$$$___$$___$__$$(address,uint256)
 
 "#]]);
 });
@@ -70,66 +72,6 @@ canCall(address,address,bytes4)
 "#]]);
 });
 
-casttest!(upload_signatures, |_prj, cmd| {
-    // test no prefix is accepted as function
-    let output = cmd
-        .args(["upload-signature", "transfer(address,uint256)"])
-        .assert_success()
-        .get_output()
-        .stdout_lossy();
-    assert!(output.contains("Function transfer(address,uint256): 0xa9059cbb"), "{}", output);
-
-    // test event prefix
-    cmd.args(["upload-signature", "event Transfer(address,uint256)"]);
-    let output = cmd.assert_success().get_output().stdout_lossy();
-    assert!(output.contains("Event Transfer(address,uint256): 0x69ca02dd4edd7bf0a4abb9ed3b7af3f14778db5d61921c7dc7cd545266326de2"), "{}", output);
-
-    // test error prefix
-    cmd.args(["upload-signature", "error ERC20InsufficientBalance(address,uint256,uint256)"]);
-    let output = cmd.assert_success().get_output().stdout_lossy();
-    assert!(
-        output.contains("Function ERC20InsufficientBalance(address,uint256,uint256): 0xe450d38c"),
-        "{}",
-        output
-    ); // Custom error is interpreted as function
-
-    // test multiple sigs
-    cmd.args([
-        "upload-signature",
-        "event Transfer(address,uint256)",
-        "transfer(address,uint256)",
-        "approve(address,uint256)",
-    ]);
-    let output = cmd.assert_success().get_output().stdout_lossy();
-    assert!(output.contains("Event Transfer(address,uint256): 0x69ca02dd4edd7bf0a4abb9ed3b7af3f14778db5d61921c7dc7cd545266326de2"), "{}", output);
-    assert!(output.contains("Function transfer(address,uint256): 0xa9059cbb"), "{}", output);
-    assert!(output.contains("Function approve(address,uint256): 0x095ea7b3"), "{}", output);
-
-    // test abi
-    cmd.args([
-        "upload-signature",
-        "event Transfer(address,uint256)",
-        "transfer(address,uint256)",
-        "error ERC20InsufficientBalance(address,uint256,uint256)",
-        Path::new(env!("CARGO_MANIFEST_DIR"))
-            .join("tests/fixtures/ERC20Artifact.json")
-            .as_os_str()
-            .to_str()
-            .unwrap(),
-    ]);
-    let output = cmd.assert_success().get_output().stdout_lossy();
-    assert!(output.contains("Event Transfer(address,uint256): 0x69ca02dd4edd7bf0a4abb9ed3b7af3f14778db5d61921c7dc7cd545266326de2"), "{}", output);
-    assert!(output.contains("Function transfer(address,uint256): 0xa9059cbb"), "{}", output);
-    assert!(output.contains("Function approve(address,uint256): 0x095ea7b3"), "{}", output);
-    assert!(output.contains("Function decimals(): 0x313ce567"), "{}", output);
-    assert!(output.contains("Function allowance(address,address): 0xdd62ed3e"), "{}", output);
-    assert!(
-        output.contains("Function ERC20InsufficientBalance(address,uint256,uint256): 0xe450d38c"),
-        "{}",
-        output
-    );
-});
-
 // tests cast can decode event with provided signature
 casttest!(event_decode_with_sig, |_prj, cmd| {
     cmd.args(["decode-event", "--sig", "MyEvent(uint256,address)", "0x000000000000000000000000000000000000000000000000000000000000004e0000000000000000000000000000000000000000000000000000000000d0004f"]).assert_success().stdout_eq(str![[r#"
diff --git a/crates/common/src/selectors.rs b/crates/common/src/selectors.rs
@@ -7,7 +7,7 @@ use alloy_json_abi::JsonAbi;
 use alloy_primitives::{B256, Selector, map::HashMap};
 use eyre::Context;
 use itertools::Itertools;
-use serde::{Deserialize, Serialize, de::DeserializeOwned};
+use serde::{Deserialize, Serialize};
 use std::{
     fmt,
     sync::{
@@ -19,7 +19,6 @@ use std::{
 
 const BASE_URL: &str = "https://sourcify.dev/server";
 const SELECTOR_LOOKUP_URL: &str = "https://sourcify.dev/server/signature-database/v1/lookup";
-const SELECTOR_IMPORT_URL: &str = "https://sourcify.dev/server/signature-database/v1/import";
 
 /// The standard request timeout for API requests.
 const REQ_TIMEOUT: Duration = Duration::from_secs(15);
@@ -70,24 +69,6 @@ impl SourcifyClient {
             .inspect_err(|err| self.on_reqwest_err(err))
     }
 
-    /// Sends a new post request
-    async fn post_json<T: Serialize + std::fmt::Debug, R: DeserializeOwned>(
-        &self,
-        url: &str,
-        body: &T,
-    ) -> reqwest::Result<R> {
-        trace!(%url, body=?serde_json::to_string(body), "POST");
-        self.inner
-            .post(url)
-            .json(body)
-            .send()
-            .await
-            .inspect_err(|err| self.on_reqwest_err(err))?
-            .json()
-            .await
-            .inspect_err(|err| self.on_reqwest_err(err))
-    }
-
     fn on_reqwest_err(&self, err: &reqwest::Error) {
         fn is_connectivity_err(err: &reqwest::Error) -> bool {
             if err.is_timeout() || err.is_connect() {
@@ -280,42 +261,6 @@ impl SourcifyClient {
         }
         Ok(possible_info)
     }
-
-    /// uploads selectors to Sourcify using the given data
-    pub async fn import_selectors(
-        &self,
-        data: SelectorImportData,
-    ) -> eyre::Result<SelectorImportResponse> {
-        self.ensure_not_spurious()?;
-
-        let request = match data {
-            SelectorImportData::Abi(abis) => {
-                let functions_and_errors: SourcifySignatures = abis
-                    .iter()
-                    .flat_map(|abi| {
-                        abi.functions()
-                            .map(|func| func.signature())
-                            .chain(abi.errors().map(|error| error.signature()))
-                            .collect::<Vec<_>>()
-                    })
-                    .collect();
-
-                let events = abis
-                    .iter()
-                    .flat_map(|abi| abi.events().map(|event| event.signature()))
-                    .collect::<Vec<_>>();
-
-                SelectorImportRequest { function: functions_and_errors, event: events }
-            }
-            SelectorImportData::Raw(raw) => {
-                let function_and_error =
-                    raw.function.iter().chain(raw.error.iter()).cloned().collect::<Vec<_>>();
-                SelectorImportRequest { function: function_and_error, event: raw.event }
-            }
-        };
-
-        Ok(self.post_json(SELECTOR_IMPORT_URL, &request).await?)
-    }
 }
 
 pub enum SelectorOrSig {
@@ -447,61 +392,6 @@ impl RawSelectorImportData {
     }
 }
 
-#[derive(Serialize)]
-#[serde(untagged)]
-pub enum SelectorImportData {
-    Abi(Vec<JsonAbi>),
-    Raw(RawSelectorImportData),
-}
-
-#[derive(Debug, Default, Serialize)]
-struct SelectorImportRequest {
-    function: SourcifySignatures,
-    event: SourcifySignatures,
-}
-
-#[derive(Debug, Deserialize)]
-struct SelectorImportEffect {
-    imported: HashMap<String, String>,
-    duplicated: HashMap<String, String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct SelectorImportResult {
-    function: SelectorImportEffect,
-    event: SelectorImportEffect,
-}
-
-#[derive(Debug, Deserialize)]
-pub struct SelectorImportResponse {
-    result: SelectorImportResult,
-}
-
-impl SelectorImportResponse {
-    /// Print info about the functions which were uploaded or already known
-    pub fn describe(&self) {
-        self.result.function.imported.iter().for_each(|(k, v)| {
-            let _ = sh_println!("Imported: Function {k}: {v}");
-        });
-        self.result.event.imported.iter().for_each(|(k, v)| {
-            let _ = sh_println!("Imported: Event {k}: {v}");
-        });
-        self.result.function.duplicated.iter().for_each(|(k, v)| {
-            let _ = sh_println!("Duplicated: Function {k}: {v}");
-        });
-        self.result.event.duplicated.iter().for_each(|(k, v)| {
-            let _ = sh_println!("Duplicated: Event {k}: {v}");
-        });
-
-        let _ = sh_println!("Selectors successfully uploaded to Sourcify");
-    }
-}
-
-/// uploads selectors to Sourcify using the given data
-pub async fn import_selectors(data: SelectorImportData) -> eyre::Result<SelectorImportResponse> {
-    SourcifyClient::new()?.import_selectors(data).await
-}
-
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct ParsedSignatures {
     pub signatures: RawSelectorImportData,
diff --git a/crates/forge/src/cmd/selectors.rs b/crates/forge/src/cmd/selectors.rs
@@ -7,8 +7,7 @@ use foundry_cli::{
     utils::{FoundryPathExt, cache_local_signatures},
 };
 use foundry_common::{
-    compile::{PathOrContractInfo, ProjectCompiler, compile_target},
-    selectors::{SelectorImportData, import_selectors},
+    compile::{PathOrContractInfo, ProjectCompiler},
     shell,
 };
 use foundry_compilers::{artifacts::output_selection::ContractOutputSelection, info::ContractInfo};
@@ -32,7 +31,7 @@ pub enum SelectorsSubcommands {
         build: Box<BuildOpts>,
     },
 
-    /// Upload selectors to registry
+    /// DEPRECATED: Upload selectors to registry
     #[command(visible_alias = "up")]
     Upload {
         /// The name of the contract to upload selectors for.
@@ -100,77 +99,13 @@ impl SelectorsSubcommands {
                 let outcome = ProjectCompiler::new().quiet(true).compile(&project)?;
                 cache_local_signatures(&outcome)?;
             }
-            Self::Upload { contract, all, project_paths } => {
-                let build_args = BuildOpts {
-                    project_paths: project_paths.clone(),
-                    compiler: CompilerOpts {
-                        extra_output: vec![ContractOutputSelection::Abi],
-                        ..Default::default()
-                    },
-                    ..Default::default()
-                };
-
-                let project = build_args.project()?;
-                let output = if let Some(contract_info) = &contract {
-                    let Some(contract_name) = contract_info.name() else {
-                        eyre::bail!("No contract name provided.")
-                    };
-
-                    let target_path = contract_info
-                        .path()
-                        .map(Ok)
-                        .unwrap_or_else(|| project.find_contract_path(contract_name))?;
-                    compile_target(&target_path, &project, false)?
-                } else {
-                    ProjectCompiler::new().compile(&project)?
-                };
-                let artifacts = if all {
-                    output
-                        .into_artifacts_with_files()
-                        .filter(|(file, _, _)| {
-                            let is_sources_path = file.starts_with(&project.paths.sources);
-                            let is_test = file.is_sol_test();
-
-                            is_sources_path && !is_test
-                        })
-                        .map(|(_, contract, artifact)| (contract, artifact))
-                        .collect()
-                } else {
-                    let contract_info = contract.unwrap();
-                    let contract = contract_info.name().unwrap().to_string();
-
-                    let found_artifact = if let Some(path) = contract_info.path() {
-                        output.find(project.root().join(path).as_path(), &contract)
-                    } else {
-                        output.find_first(&contract)
-                    };
-
-                    let artifact = found_artifact
-                        .ok_or_else(|| {
-                            eyre::eyre!(
-                                "Could not find artifact `{contract}` in the compiled artifacts"
-                            )
-                        })?
-                        .clone();
-                    vec![(contract, artifact)]
-                };
-
-                let mut artifacts = artifacts.into_iter().peekable();
-                while let Some((contract, artifact)) = artifacts.next() {
-                    let abi = artifact.abi.ok_or_else(|| eyre::eyre!("Unable to fetch abi"))?;
-                    if abi.functions.is_empty() && abi.events.is_empty() && abi.errors.is_empty() {
-                        continue;
-                    }
-
-                    sh_println!("Uploading selectors for {contract}...")?;
-
-                    // upload abi to selector database
-                    import_selectors(SelectorImportData::Abi(vec![abi])).await?.describe();
-
-                    if artifacts.peek().is_some() {
-                        sh_println!()?
-                    }
-                }
+            Self::Upload { .. } => {
+                sh_eprintln!(
+                    "Selector uploading is deprecated and is currently a no-op, as the upstream API has been removed."
+                )?;
+                sh_eprintln!(
+                    "To upload selectors in the future, verify your contracts with Sourcify."
+                )?;
             }
             Self::Collision { mut first_contract, mut second_contract, build } => {
                 // Compile the project with the two contracts included
diff --git a/crates/forge/tests/cli/test_cmd.rs b/crates/forge/tests/cli/test_cmd.rs
