apollo_gateway: use proof manager

Author: einat-starkware

crates/apollo_gateway/src/errors.rs

@@ -10,6 +10,7 @@ use apollo_gateway_types::errors::GatewaySpecError;
 use apollo_gateway_types::gateway_types::SUPPORTED_TRANSACTION_VERSIONS;
 use apollo_mempool_types::communication::{MempoolClientError, MempoolClientResult};
 use apollo_mempool_types::errors::MempoolError;
+use apollo_proof_manager_types::{ProofManagerClientError, ProofManagerError};
 use blockifier::state::errors::StateError;
 use reqwest::StatusCode;
 use serde_json::{Error as SerdeError, Value};
@@ -453,3 +454,25 @@ fn convert_sn_api_error(err: StarknetApiError) -> StarknetError {
         StarknetApiError::InvalidProofFacts(_) => todo!(),
     }
 }
+
+pub fn convert_proof_manager_error(err: ProofManagerClientError) -> StarknetError {
+    match err {
+        ProofManagerClientError::ClientError(client_error) => {
+            StarknetError::internal_with_logging("Proof manager client error", &client_error)
+        }
+        ProofManagerClientError::ProofManagerError(proof_manager_error) => {
+            match proof_manager_error {
+                ProofManagerError::Client(_) => StarknetError::internal_with_logging(
+                    "Proof manager error",
+                    &proof_manager_error,
+                ),
+                ProofManagerError::ProofStorage(_) | ProofManagerError::Io(_) => {
+                    StarknetError::internal_with_logging(
+                        "Proof manager storage error",
+                        &proof_manager_error,
+                    )
+                }
+            }
+        }
+    }
+}

crates/apollo_gateway/src/gateway.rs

@@ -32,12 +32,14 @@ use starknet_api::rpc_transaction::{
     InternalRpcTransaction,
     InternalRpcTransactionWithoutTxHash,
     RpcDeclareTransaction,
+    RpcInvokeTransaction,
     RpcTransaction,
 };
 use starknet_api::transaction::fields::TransactionSignature;
 use tracing::{debug, warn};
 
 use crate::errors::{
+    convert_proof_manager_error,
     mempool_client_result_to_deprecated_gw_result,
     transaction_converter_err_to_deprecated_gw_err,
     GatewayResult,
@@ -135,6 +137,18 @@ impl Gateway {
         // Perform stateless validations.
         self.stateless_tx_validator.validate(&tx)?;
 
+        // TODO(Einat): Consider moving to `convert_rpc_tx_to_internal_and_executable_txs` function.
+        // If a transaction has a proof then we add it to the proof manager.
+        if let RpcTransaction::Invoke(RpcInvokeTransaction::V3(ref tx)) = tx {
+            if !tx.proof_facts.is_empty() {
+                let proof_facts_hash = tx.proof_facts.hash();
+                self.proof_manager_client
+                    .set_proof(proof_facts_hash, tx.proof.clone())
+                    .await
+                    .map_err(convert_proof_manager_error)?;
+            }
+        }
+
         let tx_signature = tx.signature().clone();
         let (internal_tx, executable_tx) =
             self.convert_rpc_tx_to_internal_and_executable_txs(tx, &tx_signature).await?;

crates/apollo_gateway/src/gateway_test.rs

@@ -53,6 +53,7 @@ use starknet_api::executable_transaction::AccountTransaction;
 use starknet_api::rpc_transaction::{
     InternalRpcTransaction,
     RpcDeclareTransaction,
+    RpcInvokeTransaction,
     RpcTransaction,
     RpcTransactionLabelValue,
 };
@@ -278,7 +279,17 @@ async fn setup_mock_state(
 ) {
     let input_tx = tx_args.get_rpc_tx();
     let expected_internal_tx = tx_args.get_internal_tx();
-
+    if let RpcTransaction::Invoke(RpcInvokeTransaction::V3(ref v3_tx)) = input_tx {
+        if !v3_tx.proof_facts.is_empty() {
+            let proof_facts_hash = v3_tx.proof_facts.hash();
+            mock_dependencies
+                .mock_proof_manager_client
+                .expect_set_proof()
+                .once()
+                .with(eq(proof_facts_hash), eq(v3_tx.proof.clone()))
+                .return_once(|_, _| Ok(()));
+        }
+    }
     setup_transaction_converter_mock(&mut mock_dependencies.mock_transaction_converter, tx_args);
 
     let address = expected_internal_tx.contract_address();
@@ -570,6 +581,18 @@ async fn add_tx_returns_error_when_extract_state_nonce_and_run_validations_fails
         .return_once(|| Ok(Box::new(mock_stateful_transaction_validator)));
 
     let tx_args = invoke_args();
+    let input_tx = tx_args.get_rpc_tx();
+    if let RpcTransaction::Invoke(RpcInvokeTransaction::V3(ref v3_tx)) = input_tx {
+        if !v3_tx.proof_facts.is_empty() {
+            let proof_facts_hash = v3_tx.proof_facts.hash();
+            mock_dependencies
+                .mock_proof_manager_client
+                .expect_set_proof()
+                .once()
+                .with(eq(proof_facts_hash), eq(v3_tx.proof.clone()))
+                .return_once(|_, _| Ok(()));
+        }
+    }
     setup_transaction_converter_mock(&mut mock_dependencies.mock_transaction_converter, &tx_args);
     let gateway = Gateway {
         config: Arc::new(mock_dependencies.config),
@@ -580,7 +603,7 @@ async fn add_tx_returns_error_when_extract_state_nonce_and_run_validations_fails
         proof_manager_client: Arc::new(mock_dependencies.mock_proof_manager_client),
     };
 
-    let result = gateway.add_tx(tx_args.get_rpc_tx(), None).await;
+    let result = gateway.add_tx(input_tx, None).await;
 
     assert!(result.is_err());
     assert_eq!(result.unwrap_err().code, error_code);
@@ -600,6 +623,7 @@ async fn stateless_transaction_validator_error(mut mock_dependencies: MockDepend
         .expect_validate()
         .return_once(|_| arbitrary_validation_error);
     mock_dependencies.mock_stateless_transaction_validator = mock_stateless_transaction_validator;
+
     let gateway = mock_dependencies.gateway();
     let result = gateway.add_tx(invoke_args().get_rpc_tx(), None).await;
 
@@ -623,6 +647,18 @@ async fn add_tx_returns_error_when_instantiating_validator_fails(
         .return_once(|| Err(expected_error));
 
     let tx_args = invoke_args();
+    let input_tx = tx_args.get_rpc_tx();
+    if let RpcTransaction::Invoke(RpcInvokeTransaction::V3(ref v3_tx)) = input_tx {
+        if !v3_tx.proof_facts.is_empty() {
+            let proof_facts_hash = v3_tx.proof_facts.hash();
+            mock_dependencies
+                .mock_proof_manager_client
+                .expect_set_proof()
+                .once()
+                .with(eq(proof_facts_hash), eq(v3_tx.proof.clone()))
+                .return_once(|_, _| Ok(()));
+        }
+    }
     setup_transaction_converter_mock(&mut mock_dependencies.mock_transaction_converter, &tx_args);
     let gateway = Gateway {
         config: Arc::new(mock_dependencies.config),
@@ -633,7 +669,7 @@ async fn add_tx_returns_error_when_instantiating_validator_fails(
         proof_manager_client: Arc::new(mock_dependencies.mock_proof_manager_client),
     };
 
-    let result = gateway.add_tx(tx_args.get_rpc_tx(), None).await;
+    let result = gateway.add_tx(input_tx, None).await;
 
     assert!(result.is_err());
     assert_eq!(result.unwrap_err().code, error_code);