chore(kms-connector): remove check decryption already done (#2030)

* chore(kms-connector): remove check decryption already done

* chore(kms-connector): remove useless mock

Author: eudelins-zama

kms-connector/crates/kms-worker/src/core/event_processor/decryption.rs

@@ -76,26 +76,6 @@ where
         }
     }
 
-    pub async fn check_decryption_not_already_done(
-        &self,
-        decryption_id: U256,
-    ) -> Result<(), ProcessingError> {
-        let is_decryption_done = self
-            .decryption_contract
-            .isDecryptionDone(decryption_id)
-            .call()
-            .await
-            .map_err(|e| ProcessingError::Recoverable(anyhow::Error::from(e)))?;
-
-        if is_decryption_done {
-            return Err(ProcessingError::Irrecoverable(anyhow!(
-                "Decryption already done on the Gateway"
-            )));
-        }
-
-        Ok(())
-    }
-
     #[tracing::instrument(skip_all)]
     pub async fn check_ciphertexts_allowed_for_public_decryption(
         &self,
@@ -427,65 +407,10 @@ mod tests {
     enum ExpectedOutcome {
         Ok,
         Recoverable,
+        #[allow(unused)]
         Irrecoverable,
     }
 
-    enum DecryptionReadyMock {
-        Failure(&'static str),
-        Success(bool),
-    }
-
-    #[rstest]
-    #[case::transport_error(
-        DecryptionReadyMock::Failure("Transport Error"),
-        ExpectedOutcome::Recoverable
-    )]
-    #[case::not_done(DecryptionReadyMock::Success(false), ExpectedOutcome::Ok)]
-    #[case::already_done(DecryptionReadyMock::Success(true), ExpectedOutcome::Irrecoverable)]
-    #[tokio::test]
-    async fn check_decryption_not_already_done(
-        #[case] mock_response: DecryptionReadyMock,
-        #[case] expected: ExpectedOutcome,
-    ) {
-        let asserter = Asserter::new();
-        let mock_provider = ProviderBuilder::new()
-            .disable_recommended_fillers()
-            .connect_mocked_client(asserter.clone());
-        let acl_contracts_mock = HashMap::from([(
-            u64::default(),
-            ACL::new(Address::default(), mock_provider.clone()),
-        )]);
-
-        let config = Config::default();
-        let s3_service = S3Service::new(&config, mock_provider.clone(), reqwest::Client::new());
-        let decryption_processor = DecryptionProcessor::new(
-            &config,
-            MockContextManager,
-            mock_provider,
-            acl_contracts_mock,
-            s3_service,
-        );
-
-        match mock_response {
-            DecryptionReadyMock::Failure(msg) => asserter.push_failure_msg(msg),
-            DecryptionReadyMock::Success(val) => asserter.push_success(&val.abi_encode()),
-        }
-
-        let result = decryption_processor
-            .check_decryption_not_already_done(U256::ZERO)
-            .await;
-
-        match expected {
-            ExpectedOutcome::Ok => result.unwrap(),
-            ExpectedOutcome::Recoverable => {
-                assert!(matches!(result, Err(ProcessingError::Recoverable(_))))
-            }
-            ExpectedOutcome::Irrecoverable => {
-                assert!(matches!(result, Err(ProcessingError::Irrecoverable(_))))
-            }
-        }
-    }
-
     enum PubDecryptACLMock {
         Failure(&'static str),
         Success(bool),

kms-connector/crates/kms-worker/src/core/event_processor/processor.rs

@@ -124,9 +124,6 @@ impl<GP: Provider, HP: Provider, C: ContextManager> DbEventProcessor<GP, HP, C>
     ) -> Result<KmsGrpcRequest, ProcessingError> {
         let request = match &event.kind {
             GatewayEventKind::PublicDecryption(req) => {
-                self.decryption_processor
-                    .check_decryption_not_already_done(req.decryptionId)
-                    .await?;
                 self.decryption_processor
                     .check_ciphertexts_allowed_for_public_decryption(&req.snsCtMaterials)
                     .await?;

kms-connector/crates/kms-worker/tests/acl.rs

@@ -1,10 +1,7 @@
 mod common;
 
 use crate::common::{create_mock_user_decryption_request_tx, init_kms_worker};
-use alloy::{
-    providers::{ProviderBuilder, mock::Asserter},
-    sol_types::SolValue,
-};
+use alloy::providers::{ProviderBuilder, mock::Asserter};
 use connector_utils::{
     tests::{
         db::requests::{
@@ -45,10 +42,7 @@ async fn test_decryption_acl_failure(#[case] event_type: EventType) -> anyhow::R
         .with_tx_hash(tx_hash);
     for _ in 0..MAX_DECRYPTION_ATTEMPTS {
         match event_type {
-            EventType::PublicDecryptionRequest => {
-                // Mocking isDecryptionDone returns false
-                asserter.push_success(&false.abi_encode());
-            }
+            EventType::PublicDecryptionRequest => (),
             EventType::UserDecryptionRequest => {
                 // Mocking `get_transaction_by_hash` call result
                 let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;

kms-connector/crates/kms-worker/tests/attempt_limit.rs

@@ -60,18 +60,11 @@ async fn test_request_processing(#[case] event_type: EventType) -> anyhow::Resul
         .with_sns_ct_materials(vec![sns_ct.clone()])
         .with_tx_hash(tx_hash);
     for attempt in 0..MAX_DECRYPTION_ATTEMPTS {
-        match event_type {
-            EventType::PublicDecryptionRequest => {
-                // Mocking isDecryptionDone returns false
-                asserter.push_success(&false.abi_encode());
-            }
-            EventType::UserDecryptionRequest => {
-                // Mocking `get_transaction_by_hash` call result
-                let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;
-                asserter.push_success(&mock_tx);
-            }
-            _ => (),
-        };
+        if matches!(event_type, EventType::UserDecryptionRequest) {
+            // Mocking `get_transaction_by_hash` call result
+            let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;
+            asserter.push_success(&mock_tx);
+        }
 
         // First attempt, the copro URL is not cached yet
         if attempt == 0 {

kms-connector/crates/kms-worker/tests/context.rs

@@ -52,18 +52,11 @@ async fn test_decryption_context_not_found(#[case] event_type: EventType) -> any
         .with_context_id(unknown_context_id);
 
     for _ in 0..MAX_DECRYPTION_ATTEMPTS {
-        match event_type {
-            EventType::PublicDecryptionRequest => {
-                // Mocking isDecryptionDone returns false
-                asserter.push_success(&false.abi_encode());
-            }
-            EventType::UserDecryptionRequest => {
-                // Mocking `get_transaction_by_hash` call result
-                let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;
-                asserter.push_success(&mock_tx);
-            }
-            _ => panic!("Unexpected event type"),
-        };
+        if matches!(event_type, EventType::UserDecryptionRequest) {
+            // Mocking `get_transaction_by_hash` call result
+            let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;
+            asserter.push_success(&mock_tx);
+        }
     }
 
     let gateway_mock_provider = ProviderBuilder::new()

kms-connector/crates/kms-worker/tests/integration_tests.rs

@@ -70,20 +70,13 @@ async fn test_processing_request(
     let mut insert_options = InsertRequestOptions::new()
         .with_already_sent(already_sent)
         .with_sns_ct_materials(vec![sns_ct.clone()]);
-    match event_type {
-        EventType::PublicDecryptionRequest => {
-            // Mocking isDecryptionDone returns false
-            asserter.push_success(&false.abi_encode());
-        }
-        EventType::UserDecryptionRequest => {
-            // Mocking `get_transaction_by_hash` call result
-            let tx_hash = rand_digest();
-            let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;
-            insert_options = insert_options.with_tx_hash(tx_hash);
-            asserter.push_success(&mock_tx);
-        }
-        _ => (),
-    };
+    if matches!(event_type, EventType::UserDecryptionRequest) {
+        // Mocking `get_transaction_by_hash` call result
+        let tx_hash = rand_digest();
+        let mock_tx = create_mock_user_decryption_request_tx(tx_hash, sns_ct.ctHandle)?;
+        insert_options = insert_options.with_tx_hash(tx_hash);
+        asserter.push_success(&mock_tx);
+    }
 
     let get_copro_call_response = Coprocessor {
         s3BucketUrl: format!("{}/ct128", test_instance.s3_url()),