eth-bytecode-db: add sourcify verify-from-etherscan implementation

eth-bytecode-db/eth-bytecode-db-proto/proto/v2/api_config_http.yaml

@@ -45,6 +45,10 @@ http:
       post: /api/v2/verifier/sourcify/sources:verify
       body: "*"
 
+    - selector: blockscout.ethBytecodeDb.v2.SourcifyVerifier.VerifyFromEtherscan
+      post: /api/v2/verifier/sourcify/sources:verify-from-etherscan
+      body: "*"
+
     #################### Health ####################
 
     - selector: blockscout.ethBytecodeDb.v2.Health.Check

eth-bytecode-db/eth-bytecode-db-proto/proto/v2/eth-bytecode-db.proto

@@ -28,6 +28,8 @@ service VyperVerifier {
 
 service SourcifyVerifier {
   rpc Verify(VerifySourcifyRequest) returns (VerifyResponse) {}
+
+  rpc VerifyFromEtherscan(VerifyFromEtherscanSourcifyRequest) returns (VerifyResponse) {}
 }
 
 message Source {
@@ -184,6 +186,14 @@ message SearchSourcifySourcesRequest {
   string contract_address = 2;
 }
 
+message VerifyFromEtherscanSourcifyRequest {
+  /// Address of the contract to be verified
+  string address = 1;
+  /// The chain (network) the contract was deployed to
+  /// (https://docs.sourcify.dev/docs/api/chains/)
+  string chain = 2;
+}
+
 message SearchSourcesResponse {
   repeated Source sources = 1;
 }

eth-bytecode-db/eth-bytecode-db-proto/swagger/v2/eth-bytecode-db.swagger.yaml

@@ -127,6 +127,26 @@ paths:
             $ref: '#/definitions/v2VerifySourcifyRequest'
       tags:
         - SourcifyVerifier
+  /api/v2/verifier/sourcify/sources:verify-from-etherscan:
+    post:
+      operationId: SourcifyVerifier_VerifyFromEtherscan
+      responses:
+        "200":
+          description: A successful response.
+          schema:
+            $ref: '#/definitions/v2VerifyResponse'
+        default:
+          description: An unexpected error response.
+          schema:
+            $ref: '#/definitions/googlerpcStatus'
+      parameters:
+        - name: body
+          in: body
+          required: true
+          schema:
+            $ref: '#/definitions/v2VerifyFromEtherscanSourcifyRequest'
+      tags:
+        - SourcifyVerifier
   /api/v2/verifier/vyper/sources:verify-multi-part:
     post:
       operationId: VyperVerifier_VerifyMultiPart
@@ -337,6 +357,17 @@ definitions:
       contractAddress:
         type: string
         title: / The address of the contract to be verified
+  v2VerifyFromEtherscanSourcifyRequest:
+    type: object
+    properties:
+      address:
+        type: string
+        title: / Address of the contract to be verified
+      chain:
+        type: string
+        title: |-
+          / The chain (network) the contract was deployed to
+          / (https://docs.sourcify.dev/docs/api/chains/)
   v2VerifyResponse:
     type: object
     properties:

eth-bytecode-db/eth-bytecode-db-server/Cargo.toml

@@ -28,7 +28,7 @@ tonic = "0.8"
 tracing = "0.1"
 
 [dev-dependencies]
-smart-contract-verifier-proto = { git = "https://github.com/blockscout/blockscout-rs", rev = "52c41ec" }
+smart-contract-verifier-proto = { git = "https://github.com/blockscout/blockscout-rs", rev = "e003306" }
 
 hex = "0.4.3"
 mockall = "0.11"

eth-bytecode-db/eth-bytecode-db-server/src/proto.rs

@@ -4,7 +4,7 @@ pub use eth_bytecode_db_proto::blockscout::eth_bytecode_db::v2::{
     sourcify_verifier_server, verify_response, vyper_verifier_actix, vyper_verifier_server,
     BytecodeType, HealthCheckRequest, HealthCheckResponse, ListCompilerVersionsRequest,
     ListCompilerVersionsResponse, SearchSourcesRequest, SearchSourcesResponse,
-    SearchSourcifySourcesRequest, Source, VerificationMetadata, VerifyResponse,
-    VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest, VerifySourcifyRequest,
-    VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
+    SearchSourcifySourcesRequest, Source, VerificationMetadata, VerifyFromEtherscanSourcifyRequest,
+    VerifyResponse, VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest,
+    VerifySourcifyRequest, VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
 };

eth-bytecode-db/eth-bytecode-db-server/src/services/sourcify_verifier.rs

@@ -1,10 +1,10 @@
 use super::verifier_base;
-use crate::proto::{sourcify_verifier_server, VerifyResponse, VerifySourcifyRequest};
-use async_trait::async_trait;
-use eth_bytecode_db::verification::{
-    sourcify::{self, VerificationRequest},
-    Client,
+use crate::proto::{
+    sourcify_verifier_server, VerifyFromEtherscanSourcifyRequest, VerifyResponse,
+    VerifySourcifyRequest,
 };
+use async_trait::async_trait;
+use eth_bytecode_db::verification::{sourcify, sourcify_from_etherscan, Client};
 
 pub struct SourcifyVerifierService {
     client: Client,
@@ -24,7 +24,7 @@ impl sourcify_verifier_server::SourcifyVerifier for SourcifyVerifierService {
     ) -> Result<tonic::Response<VerifyResponse>, tonic::Status> {
         let request = request.into_inner();
 
-        let verification_request = VerificationRequest {
+        let verification_request = sourcify::VerificationRequest {
             address: request.address,
             chain: request.chain,
             chosen_contract: request.chosen_contract,
@@ -35,4 +35,21 @@ impl sourcify_verifier_server::SourcifyVerifier for SourcifyVerifierService {
 
         verifier_base::process_verification_result(result)
     }
+
+    async fn verify_from_etherscan(
+        &self,
+        request: tonic::Request<VerifyFromEtherscanSourcifyRequest>,
+    ) -> Result<tonic::Response<VerifyResponse>, tonic::Status> {
+        let request = request.into_inner();
+
+        let verification_request = sourcify_from_etherscan::VerificationRequest {
+            address: request.address,
+            chain: request.chain,
+        };
+
+        let result =
+            sourcify_from_etherscan::verify(self.client.clone(), verification_request).await;
+
+        verifier_base::process_verification_result(result)
+    }
 }

eth-bytecode-db/eth-bytecode-db-server/tests/sourcify_from_etherscan.rs

@@ -0,0 +1,53 @@
+mod verification_test_helpers;
+
+use async_trait::async_trait;
+use eth_bytecode_db::verification;
+use eth_bytecode_db_proto::blockscout::eth_bytecode_db::v2::VerifyFromEtherscanSourcifyRequest;
+use rstest::{fixture, rstest};
+use smart_contract_verifier_proto::blockscout::smart_contract_verifier::v2 as smart_contract_verifier_v2;
+use tonic::Response;
+use verification_test_helpers::{
+    smart_contract_verifer_mock::{MockSourcifyVerifierService, SmartContractVerifierServer},
+    test_cases, VerifierService,
+};
+
+const TEST_SUITE_NAME: &str = "sourcify_from_etherscan";
+
+const ROUTE: &str = "/api/v2/verifier/sourcify/sources:verify-from-etherscan";
+
+#[async_trait]
+impl VerifierService<smart_contract_verifier_v2::VerifyResponse> for MockSourcifyVerifierService {
+    fn add_into_service(&mut self, response: smart_contract_verifier_v2::VerifyResponse) {
+        self.expect_verify_from_etherscan()
+            .returning(move |_| Ok(Response::new(response.clone())));
+    }
+
+    fn build_server(self) -> SmartContractVerifierServer {
+        SmartContractVerifierServer::new().sourcify_service(self)
+    }
+}
+
+#[fixture]
+fn service() -> MockSourcifyVerifierService {
+    MockSourcifyVerifierService::new()
+}
+
+#[rstest]
+#[tokio::test]
+#[timeout(std::time::Duration::from_secs(60))]
+#[ignore = "Needs database to run"]
+async fn test_returns_valid_source(service: MockSourcifyVerifierService) {
+    let default_request = VerifyFromEtherscanSourcifyRequest {
+        address: "".to_string(),
+        chain: "".to_string(),
+    };
+    let source_type = verification::SourceType::Solidity;
+    test_cases::test_returns_valid_source(
+        TEST_SUITE_NAME,
+        service,
+        ROUTE,
+        default_request,
+        source_type,
+    )
+    .await;
+}

eth-bytecode-db/eth-bytecode-db-server/tests/verification_test_helpers/smart_contract_verifer_mock.rs

@@ -5,9 +5,9 @@ use smart_contract_verifier_proto::blockscout::smart_contract_verifier::v2::{
     solidity_verifier_server::{SolidityVerifier, SolidityVerifierServer},
     sourcify_verifier_server::{SourcifyVerifier, SourcifyVerifierServer},
     vyper_verifier_server::{VyperVerifier, VyperVerifierServer},
-    ListCompilerVersionsRequest, ListCompilerVersionsResponse, VerifyResponse,
-    VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest, VerifySourcifyRequest,
-    VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
+    ListCompilerVersionsRequest, ListCompilerVersionsResponse, VerifyFromEtherscanSourcifyRequest,
+    VerifyResponse, VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest,
+    VerifySourcifyRequest, VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
 };
 use std::net::SocketAddr;
 use tokio::net::TcpListener;
@@ -47,6 +47,8 @@ mock! {
     #[async_trait::async_trait]
     impl SourcifyVerifier for SourcifyVerifierService {
         async fn verify(&self, request: tonic::Request<VerifySourcifyRequest>) -> Result<tonic::Response<VerifyResponse>, tonic::Status>;
+
+        async fn verify_from_etherscan(&self, request: tonic::Request<VerifyFromEtherscanSourcifyRequest>) -> Result<tonic::Response<VerifyResponse>, tonic::Status>;
     }
 }
 

eth-bytecode-db/eth-bytecode-db/Cargo.toml

@@ -28,7 +28,7 @@ reqwest = "0.11.18"
 semver = "1.0"
 serde = "1.0"
 serde_json = "1.0"
-smart-contract-verifier-proto = { git = "https://github.com/blockscout/blockscout-rs", rev = "52c41ec" }
+smart-contract-verifier-proto = { git = "https://github.com/blockscout/blockscout-rs", rev = "e003306" }
 solidity-metadata = "1.0"
 thiserror = "1.0"
 tokio = "1.22"

eth-bytecode-db/eth-bytecode-db/src/verification/handlers/mod.rs

@@ -2,6 +2,7 @@ pub mod compiler_versions;
 pub mod solidity_multi_part;
 pub mod solidity_standard_json;
 pub mod sourcify;
+pub mod sourcify_from_etherscan;
 pub mod vyper_multi_part;
 pub mod vyper_standard_json;
 

eth-bytecode-db/eth-bytecode-db/src/verification/handlers/sourcify_from_etherscan.rs

@@ -0,0 +1,35 @@
+use super::{
+    super::{
+        client::Client, errors::Error, smart_contract_verifier::VerifyFromEtherscanSourcifyRequest,
+        types::Source,
+    },
+    process_verify_response, ProcessResponseAction,
+};
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct VerificationRequest {
+    pub address: String,
+    pub chain: String,
+}
+
+impl From<VerificationRequest> for VerifyFromEtherscanSourcifyRequest {
+    fn from(request: VerificationRequest) -> Self {
+        VerifyFromEtherscanSourcifyRequest {
+            address: request.address,
+            chain: request.chain,
+        }
+    }
+}
+
+pub async fn verify(mut client: Client, request: VerificationRequest) -> Result<Source, Error> {
+    let request: VerifyFromEtherscanSourcifyRequest = request.into();
+    let response = client
+        .sourcify_client
+        .verify_from_etherscan(request)
+        .await
+        .map_err(Error::from)?
+        .into_inner();
+
+    process_verify_response(&client.db_client, response, ProcessResponseAction::IgnoreDb).await
+}

eth-bytecode-db/eth-bytecode-db/src/verification/mod.rs

@@ -8,8 +8,8 @@ mod types;
 pub use client::Client;
 pub use errors::Error;
 pub use handlers::{
-    compiler_versions, solidity_multi_part, solidity_standard_json, sourcify, vyper_multi_part,
-    vyper_standard_json,
+    compiler_versions, solidity_multi_part, solidity_standard_json, sourcify,
+    sourcify_from_etherscan, vyper_multi_part, vyper_standard_json,
 };
 pub use types::{
     BytecodePart, BytecodeType, MatchType, Source, SourceType, VerificationMetadata,

eth-bytecode-db/eth-bytecode-db/src/verification/smart_contract_verifier.rs

@@ -4,7 +4,7 @@ pub use smart_contract_verifier_proto::blockscout::smart_contract_verifier::v2::
     sourcify_verifier_client,
     verify_response::{extra_data::BytecodePart, Status},
     vyper_verifier_client, BytecodeType, ListCompilerVersionsRequest, ListCompilerVersionsResponse,
-    VerificationMetadata, VerifyResponse, VerifySolidityMultiPartRequest,
-    VerifySolidityStandardJsonRequest, VerifySourcifyRequest, VerifyVyperMultiPartRequest,
-    VerifyVyperStandardJsonRequest,
+    VerificationMetadata, VerifyFromEtherscanSourcifyRequest, VerifyResponse,
+    VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest, VerifySourcifyRequest,
+    VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
 };

eth-bytecode-db/eth-bytecode-db/tests/sourcify_from_etherscan.rs

@@ -0,0 +1,64 @@
+mod verification_test_helpers;
+
+use async_trait::async_trait;
+use eth_bytecode_db::verification::{
+    sourcify_from_etherscan, sourcify_from_etherscan::VerificationRequest, Client, Error, Source,
+    SourceType, VerificationMetadata,
+};
+use rstest::{fixture, rstest};
+use smart_contract_verifier_proto::blockscout::smart_contract_verifier::v2::{
+    VerifyFromEtherscanSourcifyRequest, VerifyResponse,
+};
+use tonic::Response;
+use verification_test_helpers::{
+    smart_contract_veriifer_mock::{MockSourcifyVerifierService, SmartContractVerifierServer},
+    VerifierService,
+};
+
+const DB_PREFIX: &str = "sourcify_from_etherscan";
+
+#[async_trait]
+impl VerifierService<VerificationRequest> for MockSourcifyVerifierService {
+    type GrpcT = VerifyFromEtherscanSourcifyRequest;
+
+    fn add_into_service(&mut self, request: Self::GrpcT, response: VerifyResponse) {
+        self.expect_verify_from_etherscan()
+            .withf(move |arg| arg.get_ref() == &request)
+            .returning(move |_| Ok(Response::new(response.clone())));
+    }
+
+    fn build_server(self) -> SmartContractVerifierServer {
+        SmartContractVerifierServer::new().sourcify_service(self)
+    }
+
+    fn generate_request(
+        &self,
+        _id: u8,
+        _metadata: Option<VerificationMetadata>,
+    ) -> VerificationRequest {
+        VerificationRequest {
+            address: "0x1234".to_string(),
+            chain: "77".to_string(),
+        }
+    }
+
+    fn source_type(&self) -> SourceType {
+        SourceType::Solidity
+    }
+
+    async fn verify(client: Client, request: VerificationRequest) -> Result<Source, Error> {
+        sourcify_from_etherscan::verify(client, request).await
+    }
+}
+
+#[fixture]
+fn service() -> MockSourcifyVerifierService {
+    MockSourcifyVerifierService::new()
+}
+
+#[rstest]
+#[tokio::test]
+#[ignore = "Needs database to run"]
+async fn returns_valid_source(service: MockSourcifyVerifierService) {
+    verification_test_helpers::test_returns_valid_source(DB_PREFIX, service).await
+}

eth-bytecode-db/eth-bytecode-db/tests/verification_test_helpers/smart_contract_veriifer_mock.rs

@@ -5,9 +5,9 @@ use smart_contract_verifier_proto::blockscout::smart_contract_verifier::v2::{
     solidity_verifier_server::{SolidityVerifier, SolidityVerifierServer},
     sourcify_verifier_server::{SourcifyVerifier, SourcifyVerifierServer},
     vyper_verifier_server::{VyperVerifier, VyperVerifierServer},
-    ListCompilerVersionsRequest, ListCompilerVersionsResponse, VerifyResponse,
-    VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest, VerifySourcifyRequest,
-    VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
+    ListCompilerVersionsRequest, ListCompilerVersionsResponse, VerifyFromEtherscanSourcifyRequest,
+    VerifyResponse, VerifySolidityMultiPartRequest, VerifySolidityStandardJsonRequest,
+    VerifySourcifyRequest, VerifyVyperMultiPartRequest, VerifyVyperStandardJsonRequest,
 };
 use std::net::SocketAddr;
 use tokio::net::TcpListener;
@@ -47,6 +47,8 @@ mock! {
     #[async_trait::async_trait]
     impl SourcifyVerifier for SourcifyVerifierService {
         async fn verify(&self, request: tonic::Request<VerifySourcifyRequest>) -> Result<tonic::Response<VerifyResponse>, tonic::Status>;
+
+        async fn verify_from_etherscan(&self, request: tonic::Request<VerifyFromEtherscanSourcifyRequest>) -> Result<tonic::Response<VerifyResponse>, tonic::Status>;
     }
 }