apollo_transaction_converter: use proof manager to convert between transactions

Author: einat-starkware

crates/apollo_gateway/src/errors.rs

@@ -362,6 +362,9 @@ pub fn transaction_converter_err_to_deprecated_gw_err(
         TransactionConverterError::ClassNotFound { .. } => {
             StarknetError::internal_with_signature_logging("Class not found", tx_signature, err)
         }
+        TransactionConverterError::ProofNotFound { .. } => {
+            StarknetError::internal_with_signature_logging("Proof not found", tx_signature, err)
+        }
         TransactionConverterError::StarknetApiError(err) => convert_sn_api_error(err),
     }
 }

crates/apollo_transaction_converter/Cargo.toml

@@ -17,6 +17,7 @@ apollo_class_manager_types.workspace = true
 apollo_proof_manager_types.workspace = true
 async-trait.workspace = true
 mockall = { workspace = true, optional = true }
+starknet-types-core.workspace = true
 starknet_api.workspace = true
 thiserror.workspace = true
 tokio.workspace = true

crates/apollo_transaction_converter/src/transaction_converter.rs

@@ -29,6 +29,7 @@ use starknet_api::state::SierraContractClass;
 use starknet_api::transaction::fields::{Fee, Proof, ProofFacts};
 use starknet_api::transaction::CalculateContractAddress;
 use starknet_api::{executable_transaction, transaction, StarknetApiError};
+use starknet_types_core::felt::Felt;
 use thiserror::Error;
 use tracing::info;
 
@@ -42,6 +43,8 @@ pub enum TransactionConverterError {
     ClassManagerClientError(#[from] ClassManagerClientError),
     #[error("Class of hash: {class_hash} not found")]
     ClassNotFound { class_hash: ClassHash },
+    #[error("Proof for proof facts hash: {facts_hash} not found.")]
+    ProofNotFound { facts_hash: Felt },
     #[error(transparent)]
     ProofManagerClientError(#[from] ProofManagerClientError),
     #[error(transparent)]
@@ -114,6 +117,12 @@ impl TransactionConverter {
             .ok_or(TransactionConverterError::ClassNotFound { class_hash })
     }
 
+    async fn get_proof(&self, proof_facts: &ProofFacts) -> TransactionConverterResult<Proof> {
+        self.proof_manager_client
+            .get_proof(proof_facts.clone())
+            .await?
+            .ok_or(TransactionConverterError::ProofNotFound { facts_hash: proof_facts.hash() })
+    }
     async fn get_executable(
         &self,
         class_hash: ClassHash,
@@ -164,6 +173,14 @@ impl TransactionConverterTrait for TransactionConverter {
     ) -> TransactionConverterResult<RpcTransaction> {
         match tx.tx {
             InternalRpcTransactionWithoutTxHash::Invoke(tx) => {
+                // We expect the proof to be available here because it has already been verified
+                // and stored by the proof manager in the gateway.
+                let proof = if tx.proof_facts.is_empty() {
+                    Proof::default()
+                } else {
+                    self.get_proof(&tx.proof_facts).await?
+                };
+
                 Ok(RpcTransaction::Invoke(RpcInvokeTransaction::V3(RpcInvokeTransactionV3 {
                     resource_bounds: tx.resource_bounds,
                     signature: tx.signature,
@@ -176,8 +193,7 @@ impl TransactionConverterTrait for TransactionConverter {
                     calldata: tx.calldata,
                     account_deployment_data: tx.account_deployment_data,
                     proof_facts: tx.proof_facts,
-                    // TODO(AvivG): get proof from proof manager once implemented.
-                    proof: Proof::default(),
+                    proof,
                 })))
             }
             InternalRpcTransactionWithoutTxHash::Declare(tx) => {
@@ -186,6 +202,8 @@ impl TransactionConverterTrait for TransactionConverter {
                     compiled_class_hash: tx.compiled_class_hash,
                     signature: tx.signature,
                     nonce: tx.nonce,
+                    // We expect the sierra to be available here because it has already been added
+                    // to the class manager in the gateway.
                     contract_class: self.get_sierra(tx.class_hash).await?,
                     resource_bounds: tx.resource_bounds,
                     tip: tx.tip,