apollo_gateway: use proof manager

Author: einat-starkware

Cargo.toml

@@ -67,8 +67,8 @@ members = [
   "crates/apollo_proc_macros",
   "crates/apollo_proc_macros_tests",
   "crates/apollo_proof_manager",
-  "crates/apollo_propeller",
   "crates/apollo_proof_manager_types",
+  "crates/apollo_propeller",
   "crates/apollo_protobuf",
   "crates/apollo_reverts",
   "crates/apollo_rpc",
@@ -186,8 +186,8 @@ apollo_p2p_sync_config.path = "crates/apollo_p2p_sync_config"
 apollo_proc_macros = { path = "crates/apollo_proc_macros", version = "0.0.0" }
 apollo_proc_macros_tests.path = "crates/apollo_proc_macros_tests"
 apollo_proof_manager.path = "crates/apollo_proof_manager"
-apollo_propeller.path = "crates/apollo_propeller"
 apollo_proof_manager_types.path = "crates/apollo_proof_manager_types"
+apollo_propeller.path = "crates/apollo_propeller"
 apollo_protobuf.path = "crates/apollo_protobuf"
 apollo_reverts.path = "crates/apollo_reverts"
 apollo_rpc.path = "crates/apollo_rpc"

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};
@@ -452,3 +453,25 @@ fn convert_sn_api_error(err: StarknetApiError) -> StarknetError {
         },
     }
 }
+
+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,17 @@ impl Gateway {
         // Perform stateless validations.
         self.stateless_tx_validator.validate(&tx)?;
 
+        // If a transaction has a proof then we add it to the proof manager.
+        if let RpcTransaction::Invoke(RpcInvokeTransaction::V3(ref v3_tx)) = tx {
+            if !v3_tx.proof_facts.is_empty() {
+                let proof_facts_hash = v3_tx.proof_facts.hash();
+                self.proof_manager_client
+                    .set_proof(proof_facts_hash, v3_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?;