feat(core): Added integrity framework for Authorize and Sync flow with connector as Stripe

crates/api_models/src/errors/types.rs

@@ -77,6 +77,8 @@ pub struct Extra {
     pub connector: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub reason: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub connector_transaction_id: Option<String>,
 }
 
 #[derive(Serialize, Debug, Clone)]

crates/common_utils/src/errors.rs

@@ -69,6 +69,15 @@ pub enum ValidationError {
     InvalidValue { message: String },
 }
 
+/// Integrity check errors.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct IntegrityCheckError {
+    /// Field names for which integrity check failed!
+    pub field_names: String,
+    /// Connector transaction reference id
+    pub connector_transaction_id: Option<String>,
+}
+
 /// Cryptographic algorithm errors
 #[derive(Debug, thiserror::Error)]
 pub enum CryptoError {

crates/hyperswitch_domain_models/src/errors/api_error_response.rs

@@ -271,6 +271,12 @@ pub enum ApiErrorResponse {
     InvalidCookie,
     #[error(error_type = ErrorType::InvalidRequestError, code = "IR_27", message = "Extended card info does not exist")]
     ExtendedCardInfoNotFound,
+    #[error(error_type = ErrorType::ServerNotAvailable, code = "IE", message = "{reason} as data mismatched for {field_names}", ignore = "status_code")]
+    IntegrityCheckFailed {
+        reason: String,
+        field_names: String,
+        connector_transaction_id: Option<String>,
+    },
     #[error(error_type = ErrorType::ProcessingError, code = "HE_06", message = "Missing tenant id")]
     MissingTenantId,
     #[error(error_type = ErrorType::ProcessingError, code = "HE_06", message = "Invalid tenant id: {tenant_id}")]
@@ -609,6 +615,19 @@ impl ErrorSwitch<api_models::errors::types::ApiErrorResponse> for ApiErrorRespon
             Self::ExtendedCardInfoNotFound => {
                 AER::NotFound(ApiError::new("IR", 27, "Extended card info does not exist", None))
             }
+            Self::IntegrityCheckFailed {
+                reason,
+                field_names,
+                connector_transaction_id
+            } => AER::InternalServerError(ApiError::new(
+                "IE",
+                0,
+                format!("{} as data mismatched for {}", reason, field_names),
+                Some(Extra {
+                    connector_transaction_id: connector_transaction_id.to_owned(),
+                    ..Default::default()
+                })
+            )),
             Self::MissingTenantId => {
                 AER::InternalServerError(ApiError::new("HE", 6, "Missing Tenant ID in the request".to_string(), None))
             }

crates/hyperswitch_domain_models/src/router_data.rs

@@ -1,6 +1,6 @@
 use std::{collections::HashMap, marker::PhantomData};
 
-use common_utils::{id_type, types::MinorUnit};
+use common_utils::{errors::IntegrityCheckError, id_type, types::MinorUnit};
 use masking::Secret;
 
 use crate::{payment_address::PaymentAddress, payment_method_data};
@@ -70,6 +70,8 @@ pub struct RouterData<Flow, Request, Response> {
 
     // minor amount for amount framework
     pub minor_amount_captured: Option<MinorUnit>,
+
+    pub integrity_check: Result<(), IntegrityCheckError>,
 }
 
 // Different patterns of authentication.

crates/hyperswitch_domain_models/src/router_request_types.rs

@@ -62,6 +62,23 @@ pub struct PaymentsAuthorizeData {
 
     // New amount for amount frame work
     pub minor_amount: MinorUnit,
+    pub integrity_object: Option<AuthoriseIntegrityObject>,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct AuthoriseIntegrityObject {
+    /// Authorise amount
+    pub amount: MinorUnit,
+    /// Authorise currency
+    pub currency: storage_enums::Currency,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct SyncIntegrityObject {
+    /// Sync amount
+    pub amount: Option<MinorUnit>,
+    /// Sync currency
+    pub currency: Option<storage_enums::Currency>,
 }
 
 #[derive(Debug, serde::Deserialize, Clone)]
@@ -348,6 +365,9 @@ pub struct PaymentsSyncData {
     pub payment_method_type: Option<storage_enums::PaymentMethodType>,
     pub currency: storage_enums::Currency,
     pub payment_experience: Option<common_enums::PaymentExperience>,
+
+    pub amount: MinorUnit,
+    pub integrity_object: Option<SyncIntegrityObject>,
 }
 
 #[derive(Debug, Default, Clone)]

crates/hyperswitch_interfaces/src/integrity.rs

@@ -0,0 +1,168 @@
+use common_utils::errors::IntegrityCheckError;
+use hyperswitch_domain_models::router_request_types::{
+    AuthoriseIntegrityObject, PaymentsAuthorizeData, PaymentsSyncData, SyncIntegrityObject,
+};
+
+/// Connector Integrity trait to check connector data integrity
+pub trait FlowIntegrity {
+    /// Output type for the connector
+    type IntegrityObject;
+    /// helps in connector integrity check
+    fn compare(
+        req_integrity_object: Self::IntegrityObject,
+        res_integrity_object: Self::IntegrityObject,
+        connector_transaction_id: Option<String>,
+    ) -> Result<(), IntegrityCheckError>;
+}
+
+/// Trait to get connector integrity object based on request and response
+pub trait GetIntegrityObject<T: FlowIntegrity> {
+    /// function to get response integrity object
+    fn get_response_integrity_object(&self) -> Option<T::IntegrityObject>;
+    /// function to get request integrity object
+    fn get_request_integrity_object(&self) -> T::IntegrityObject;
+}
+
+/// Trait to check flow type, based on which various integrity checks will be performed
+pub trait CheckIntegrity<Request, T> {
+    /// Function to check to initiate integrity check
+    fn check_integrity(
+        &self,
+        request: &Request,
+        connector_transaction_id: Option<String>,
+    ) -> Result<(), IntegrityCheckError>;
+}
+
+impl<T, Request> CheckIntegrity<Request, T> for PaymentsAuthorizeData
+where
+    T: FlowIntegrity,
+    Request: GetIntegrityObject<T>,
+{
+    fn check_integrity(
+        &self,
+        request: &Request,
+        connector_transaction_id: Option<String>,
+    ) -> Result<(), IntegrityCheckError> {
+        match request.get_response_integrity_object() {
+            Some(res_integrity_object) => {
+                let req_integrity_object = request.get_request_integrity_object();
+                T::compare(
+                    req_integrity_object,
+                    res_integrity_object,
+                    connector_transaction_id,
+                )
+            }
+            None => Ok(()),
+        }
+    }
+}
+
+impl<T, Request> CheckIntegrity<Request, T> for PaymentsSyncData
+where
+    T: FlowIntegrity,
+    Request: GetIntegrityObject<T>,
+{
+    fn check_integrity(
+        &self,
+        request: &Request,
+        connector_transaction_id: Option<String>,
+    ) -> Result<(), IntegrityCheckError> {
+        match request.get_response_integrity_object() {
+            Some(res_integrity_object) => {
+                let req_integrity_object = request.get_request_integrity_object();
+                T::compare(
+                    req_integrity_object,
+                    res_integrity_object,
+                    connector_transaction_id,
+                )
+            }
+            None => Ok(()),
+        }
+    }
+}
+
+impl FlowIntegrity for AuthoriseIntegrityObject {
+    type IntegrityObject = Self;
+    fn compare(
+        req_integrity_object: Self,
+        res_integrity_object: Self,
+        connector_transaction_id: Option<String>,
+    ) -> Result<(), IntegrityCheckError> {
+        let mut mismatched_fields = Vec::new();
+
+        if req_integrity_object.amount != res_integrity_object.amount {
+            mismatched_fields.push("amount".to_string());
+        }
+
+        if req_integrity_object.currency != res_integrity_object.currency {
+            mismatched_fields.push("currency".to_string());
+        }
+
+        if mismatched_fields.is_empty() {
+            Ok(())
+        } else {
+            let field_names = mismatched_fields.join(", ");
+
+            Err(IntegrityCheckError {
+                field_names,
+                connector_transaction_id,
+            })
+        }
+    }
+}
+
+impl FlowIntegrity for SyncIntegrityObject {
+    type IntegrityObject = Self;
+    fn compare(
+        req_integrity_object: Self,
+        res_integrity_object: Self,
+        connector_transaction_id: Option<String>,
+    ) -> Result<(), IntegrityCheckError> {
+        let mut mismatched_fields = Vec::new();
+
+        if req_integrity_object.amount != res_integrity_object.amount {
+            mismatched_fields.push("amount".to_string());
+        }
+
+        if req_integrity_object.currency != res_integrity_object.currency {
+            mismatched_fields.push("currency".to_string());
+        }
+
+        if mismatched_fields.is_empty() {
+            Ok(())
+        } else {
+            let field_names = mismatched_fields.join(", ");
+
+            Err(IntegrityCheckError {
+                field_names,
+                connector_transaction_id,
+            })
+        }
+    }
+}
+
+impl GetIntegrityObject<AuthoriseIntegrityObject> for PaymentsAuthorizeData {
+    fn get_response_integrity_object(&self) -> Option<AuthoriseIntegrityObject> {
+        self.integrity_object.clone()
+    }
+
+    fn get_request_integrity_object(&self) -> AuthoriseIntegrityObject {
+        AuthoriseIntegrityObject {
+            amount: self.minor_amount,
+            currency: self.currency,
+        }
+    }
+}
+
+impl GetIntegrityObject<SyncIntegrityObject> for PaymentsSyncData {
+    fn get_response_integrity_object(&self) -> Option<SyncIntegrityObject> {
+        self.integrity_object.clone()
+    }
+
+    fn get_request_integrity_object(&self) -> SyncIntegrityObject {
+        SyncIntegrityObject {
+            amount: Some(self.amount),
+            currency: Some(self.currency),
+        }
+    }
+}

crates/hyperswitch_interfaces/src/lib.rs

@@ -9,6 +9,8 @@ pub mod consts;
 pub mod encryption_interface;
 pub mod errors;
 pub mod events;
+/// connector integrity check interface
+pub mod integrity;
 pub mod metrics;
 pub mod secrets_interface;
 pub mod types;

crates/router/src/compatibility/stripe/errors.rs

@@ -264,6 +264,12 @@ pub enum StripeErrorCode {
     PaymentMethodDeleteFailed,
     #[error(error_type = StripeErrorType::InvalidRequestError, code = "", message = "Extended card info does not exist")]
     ExtendedCardInfoNotFound,
+    #[error(error_type = StripeErrorType::ConnectorError, code = "CE", message = "{reason} as data mismatched for {field_names}")]
+    IntegrityCheckFailed {
+        reason: String,
+        field_names: String,
+        connector_transaction_id: Option<String>,
+    },
     #[error(error_type = StripeErrorType::InvalidRequestError, code = "IR_28", message = "Invalid tenant")]
     InvalidTenant,
     #[error(error_type = StripeErrorType::HyperswitchError, code = "HE_01", message = "Failed to convert amount to {amount_type} type")]
@@ -650,6 +656,15 @@ impl From<errors::ApiErrorResponse> for StripeErrorCode {
                 Self::InvalidWalletToken { wallet_name }
             }
             errors::ApiErrorResponse::ExtendedCardInfoNotFound => Self::ExtendedCardInfoNotFound,
+            errors::ApiErrorResponse::IntegrityCheckFailed {
+                reason,
+                field_names,
+                connector_transaction_id,
+            } => Self::IntegrityCheckFailed {
+                reason,
+                field_names,
+                connector_transaction_id,
+            },
             errors::ApiErrorResponse::InvalidTenant { tenant_id: _ }
             | errors::ApiErrorResponse::MissingTenantId => Self::InvalidTenant,
             errors::ApiErrorResponse::AmountConversionFailed { amount_type } => {
@@ -741,6 +756,7 @@ impl actix_web::ResponseError for StripeErrorCode {
             Self::ExternalConnectorError { status_code, .. } => {
                 StatusCode::from_u16(*status_code).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR)
             }
+            Self::IntegrityCheckFailed { .. } => StatusCode::INTERNAL_SERVER_ERROR,
             Self::PaymentBlockedError { code, .. } => {
                 StatusCode::from_u16(*code).unwrap_or(StatusCode::OK)
             }

crates/router/src/connector/cryptopay.rs

@@ -298,7 +298,7 @@ impl ConnectorIntegration<api::Authorize, types::PaymentsAuthorizeData, types::P
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
         let capture_amount_in_minor_units = match response.data.price_amount {
-            Some(ref amount) => Some(utils::convert_back(
+            Some(ref amount) => Some(utils::convert_back_amount_to_minor_units(
                 self.amount_converter,
                 amount.clone(),
                 data.request.currency,
@@ -393,7 +393,7 @@ impl ConnectorIntegration<api::PSync, types::PaymentsSyncData, types::PaymentsRe
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
         let capture_amount_in_minor_units = match response.data.price_amount {
-            Some(ref amount) => Some(utils::convert_back(
+            Some(ref amount) => Some(utils::convert_back_amount_to_minor_units(
                 self.amount_converter,
                 amount.clone(),
                 data.request.currency,