Bug: [BUG] Nuvei 3ds + psync fix



### Bug Description

- 3ds transaction done via hyperswitch was not marked as 3ds in nuvei system. Make a successful 3ds transaction and search the connector transaction id in nuvei dashboard , click `linkage` . InitAuth and Auth3d is not seen.


### Expected Behavior

Actual 3ds call should have have 3 calls in linkage 1, `InitAuth`  2. `Auth3d` and 3. `sale`

### Actual Behavior

- 

### Steps To Reproduce

Provide an unambiguous set of steps to reproduce this bug. Include code or configuration to reproduce, if relevant.
1. Go to '...'
2. Click on '....'
3. Scroll down to '....'


### Context For The Bug

- Make a 3ds transaction and go to nuvei dashboard . 
- 
- Make a psync , you will see it as completed.

### Environment

Are you using hyperswitch hosted version? Yes/No
If yes, please provide the value of the `x-request-id` response header to help us debug your issue.

If not (or if building/running locally), please provide the following details:
1. Operating System or Linux distribution:
2. Rust version (output of `rustc --version`): ``
3. App version (output of `cargo r --features vergen -- --version`): ``


### Have you spent some time checking if this bug has been raised before?

- [x] I checked and didn't find a similar issue

### Have you read the Contributing Guidelines?

- [x] I have read the [Contributing Guidelines](https://github.com/juspay/hyperswitch/blob/main/docs/CONTRIBUTING.md)

### Are you willing to submit a PR?

None
diff --git a/crates/hyperswitch_connectors/src/connectors/nuvei.rs b/crates/hyperswitch_connectors/src/connectors/nuvei.rs
index 259495d0545..9c906abeefc 100644
--- a/crates/hyperswitch_connectors/src/connectors/nuvei.rs
+++ b/crates/hyperswitch_connectors/src/connectors/nuvei.rs
@@ -53,6 +53,7 @@ use masking::ExposeInterface;
 use transformers as nuvei;
 
 use crate::{
+    connectors::nuvei::transformers::{NuveiPaymentsResponse, NuveiTransactionSyncResponse},
     constants::headers,
     types::ResponseRouterData,
     utils::{self, is_mandate_supported, PaymentMethodDataType, RouterData as _},
@@ -211,7 +212,7 @@ impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsRespons
         RouterData<SetupMandate, SetupMandateRequestData, PaymentsResponseData>,
         errors::ConnectorError,
     > {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
@@ -234,72 +235,68 @@ impl ConnectorIntegration<SetupMandate, SetupMandateRequestData, PaymentsRespons
     }
 }
 
-impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
-    for Nuvei
-{
+impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Nuvei {
     fn get_headers(
         &self,
-        req: &PaymentsCompleteAuthorizeRouterData,
+        req: &PaymentsCancelRouterData,
         connectors: &Connectors,
     ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
         self.build_headers(req, connectors)
     }
+
     fn get_content_type(&self) -> &'static str {
         self.common_get_content_type()
     }
+
     fn get_url(
         &self,
-        _req: &PaymentsCompleteAuthorizeRouterData,
+        _req: &PaymentsCancelRouterData,
         connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!(
-            "{}ppp/api/v1/payment.do",
+            "{}ppp/api/v1/voidTransaction.do",
             ConnectorCommon::base_url(self, connectors)
         ))
     }
+
     fn get_request_body(
         &self,
-        req: &PaymentsCompleteAuthorizeRouterData,
+        req: &PaymentsCancelRouterData,
         _connectors: &Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let meta: nuvei::NuveiMeta = utils::to_connector_meta(req.request.connector_meta.clone())?;
-        let connector_req = nuvei::NuveiPaymentsRequest::try_from((req, meta.session_token))?;
+        let connector_req = nuvei::NuveiPaymentFlowRequest::try_from(req)?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
+
     fn build_request(
         &self,
-        req: &PaymentsCompleteAuthorizeRouterData,
+        req: &PaymentsCancelRouterData,
         connectors: &Connectors,
     ) -> CustomResult<Option<Request>, errors::ConnectorError> {
-        Ok(Some(
-            RequestBuilder::new()
-                .method(Method::Post)
-                .url(&types::PaymentsCompleteAuthorizeType::get_url(
-                    self, req, connectors,
-                )?)
-                .attach_default_headers()
-                .headers(types::PaymentsCompleteAuthorizeType::get_headers(
-                    self, req, connectors,
-                )?)
-                .set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
-                    self, req, connectors,
-                )?)
-                .build(),
-        ))
+        let request = RequestBuilder::new()
+            .method(Method::Post)
+            .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
+            .attach_default_headers()
+            .headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
+            .set_body(types::PaymentsVoidType::get_request_body(
+                self, req, connectors,
+            )?)
+            .build();
+        Ok(Some(request))
     }
+
     fn handle_response(
         &self,
-        data: &PaymentsCompleteAuthorizeRouterData,
+        data: &PaymentsCancelRouterData,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+    ) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-
         RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
@@ -317,63 +314,66 @@ impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResp
     }
 }
 
-impl ConnectorIntegration<Void, PaymentsCancelData, PaymentsResponseData> for Nuvei {
+impl ConnectorIntegration<CompleteAuthorize, CompleteAuthorizeData, PaymentsResponseData>
+    for Nuvei
+{
     fn get_headers(
         &self,
-        req: &PaymentsCancelRouterData,
+        req: &PaymentsCompleteAuthorizeRouterData,
         connectors: &Connectors,
     ) -> CustomResult<Vec<(String, masking::Maskable<String>)>, errors::ConnectorError> {
         self.build_headers(req, connectors)
     }
-
     fn get_content_type(&self) -> &'static str {
         self.common_get_content_type()
     }
-
     fn get_url(
         &self,
-        _req: &PaymentsCancelRouterData,
+        _req: &PaymentsCompleteAuthorizeRouterData,
         connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!(
-            "{}ppp/api/v1/voidTransaction.do",
+            "{}ppp/api/v1/payment.do",
             ConnectorCommon::base_url(self, connectors)
         ))
     }
-
     fn get_request_body(
         &self,
-        req: &PaymentsCancelRouterData,
+        req: &PaymentsCompleteAuthorizeRouterData,
         _connectors: &Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
-        let connector_req = nuvei::NuveiPaymentFlowRequest::try_from(req)?;
+        let meta: nuvei::NuveiMeta = utils::to_connector_meta(req.request.connector_meta.clone())?;
+        let connector_req = nuvei::NuveiPaymentsRequest::try_from((req, meta.session_token))?;
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
-
     fn build_request(
         &self,
-        req: &PaymentsCancelRouterData,
+        req: &PaymentsCompleteAuthorizeRouterData,
         connectors: &Connectors,
     ) -> CustomResult<Option<Request>, errors::ConnectorError> {
-        let request = RequestBuilder::new()
-            .method(Method::Post)
-            .url(&types::PaymentsVoidType::get_url(self, req, connectors)?)
-            .attach_default_headers()
-            .headers(types::PaymentsVoidType::get_headers(self, req, connectors)?)
-            .set_body(types::PaymentsVoidType::get_request_body(
-                self, req, connectors,
-            )?)
-            .build();
-        Ok(Some(request))
+        Ok(Some(
+            RequestBuilder::new()
+                .method(Method::Post)
+                .url(&types::PaymentsCompleteAuthorizeType::get_url(
+                    self, req, connectors,
+                )?)
+                .attach_default_headers()
+                .headers(types::PaymentsCompleteAuthorizeType::get_headers(
+                    self, req, connectors,
+                )?)
+                .set_body(types::PaymentsCompleteAuthorizeType::get_request_body(
+                    self, req, connectors,
+                )?)
+                .build(),
+        ))
     }
-
     fn handle_response(
         &self,
-        data: &PaymentsCancelRouterData,
+        data: &PaymentsCompleteAuthorizeRouterData,
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
-    ) -> CustomResult<PaymentsCancelRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+    ) -> CustomResult<PaymentsCompleteAuthorizeRouterData, errors::ConnectorError> {
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
@@ -458,7 +458,7 @@ impl ConnectorIntegration<PostCaptureVoid, PaymentsCancelPostCaptureData, Paymen
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsCancelPostCaptureRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
@@ -501,7 +501,7 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Nuv
         connectors: &Connectors,
     ) -> CustomResult<String, errors::ConnectorError> {
         Ok(format!(
-            "{}ppp/api/v1/getPaymentStatus.do",
+            "{}ppp/api/v1/getTransactionDetails.do",
             ConnectorCommon::base_url(self, connectors)
         ))
     }
@@ -546,9 +546,9 @@ impl ConnectorIntegration<PSync, PaymentsSyncData, PaymentsResponseData> for Nuv
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsSyncRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiTransactionSyncResponse = res
             .response
-            .parse_struct("NuveiPaymentsResponse")
+            .parse_struct("NuveiTransactionSyncResponse")
             .switch()?;
 
         event_builder.map(|i| i.set_response_body(&response));
@@ -622,7 +622,7 @@ impl ConnectorIntegration<Capture, PaymentsCaptureData, PaymentsResponseData> fo
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsCaptureRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
@@ -678,7 +678,6 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
         _connectors: &Connectors,
     ) -> CustomResult<RequestContent, errors::ConnectorError> {
         let connector_req = nuvei::NuveiPaymentsRequest::try_from((req, req.get_session_token()?))?;
-
         Ok(RequestContent::Json(Box::new(connector_req)))
     }
 
@@ -710,7 +709,7 @@ impl ConnectorIntegration<Authorize, PaymentsAuthorizeData, PaymentsResponseData
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsAuthorizeRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
@@ -883,13 +882,12 @@ impl ConnectorIntegration<PreProcessing, PaymentsPreProcessingData, PaymentsResp
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<PaymentsPreProcessingRouterData, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
         event_builder.map(|i| i.set_response_body(&response));
         router_env::logger::info!(connector_response=?response);
-
         RouterData::try_from(ResponseRouterData {
             response,
             data: data.clone(),
@@ -965,7 +963,7 @@ impl ConnectorIntegration<Execute, RefundsData, RefundsResponseData> for Nuvei {
         event_builder: Option<&mut ConnectorEvent>,
         res: Response,
     ) -> CustomResult<RefundsRouterData<Execute>, errors::ConnectorError> {
-        let response: nuvei::NuveiPaymentsResponse = res
+        let response: NuveiPaymentsResponse = res
             .response
             .parse_struct("NuveiPaymentsResponse")
             .switch()?;
@@ -1124,10 +1122,8 @@ impl IncomingWebhook for Nuvei {
         // Parse the webhook payload
         let webhook = serde_urlencoded::from_str::<nuvei::NuveiWebhook>(&request.query_params)
             .change_context(errors::ConnectorError::WebhookBodyDecodingFailed)?;
-
         // Convert webhook to payments response
-        let payment_response = nuvei::NuveiPaymentsResponse::from(webhook);
-
+        let payment_response = NuveiPaymentsResponse::from(webhook);
         Ok(Box::new(payment_response))
     }
 }
diff --git a/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs b/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs
index 0e032c3c804..2092fc40a20 100644
--- a/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs
+++ b/crates/hyperswitch_connectors/src/connectors/nuvei/transformers.rs
@@ -49,7 +49,8 @@ use crate::{
     utils::{
         self, convert_amount, missing_field_err, AddressData, AddressDetailsData,
         BrowserInformationData, ForeignTryFrom, PaymentsAuthorizeRequestData,
-        PaymentsCancelRequestData, PaymentsPreProcessingRequestData, RouterData as _,
+        PaymentsCancelRequestData, PaymentsPreProcessingRequestData,
+        PaymentsSetupMandateRequestData, RouterData as _,
     },
 };
 
@@ -136,9 +137,7 @@ impl NuveiAuthorizePreprocessingCommon for SetupMandateRequestData {
     fn get_return_url_required(
         &self,
     ) -> Result<String, error_stack::Report<errors::ConnectorError>> {
-        self.router_return_url
-            .clone()
-            .ok_or_else(missing_field_err("return_url"))
+        self.get_router_return_url()
     }
 
     fn get_capture_method(&self) -> Option<CaptureMethod> {
@@ -201,10 +200,6 @@ impl NuveiAuthorizePreprocessingCommon for PaymentsAuthorizeData {
         self.customer_id.clone()
     }
 
-    fn get_complete_authorize_url(&self) -> Option<String> {
-        self.complete_authorize_url.clone()
-    }
-
     fn get_connector_mandate_id(&self) -> Option<String> {
         self.connector_mandate_id().clone()
     }
@@ -219,6 +214,10 @@ impl NuveiAuthorizePreprocessingCommon for PaymentsAuthorizeData {
         self.capture_method
     }
 
+    fn get_complete_authorize_url(&self) -> Option<String> {
+        self.complete_authorize_url.clone()
+    }
+
     fn get_minor_amount_required(
         &self,
     ) -> Result<MinorUnit, error_stack::Report<errors::ConnectorError>> {
@@ -273,10 +272,6 @@ impl NuveiAuthorizePreprocessingCommon for PaymentsPreProcessingData {
             && self.setup_future_usage == Some(FutureUsage::OffSession)
     }
 
-    fn get_complete_authorize_url(&self) -> Option<String> {
-        self.complete_authorize_url.clone()
-    }
-
     fn get_connector_mandate_id(&self) -> Option<String> {
         self.connector_mandate_id()
     }
@@ -291,6 +286,10 @@ impl NuveiAuthorizePreprocessingCommon for PaymentsPreProcessingData {
         self.capture_method
     }
 
+    fn get_complete_authorize_url(&self) -> Option<String> {
+        self.complete_authorize_url.clone()
+    }
+
     fn get_minor_amount_required(
         &self,
     ) -> Result<MinorUnit, error_stack::Report<errors::ConnectorError>> {
@@ -502,7 +501,11 @@ pub struct NuveiPaymentFlowRequest {
 #[derive(Debug, Serialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub struct NuveiPaymentSyncRequest {
-    pub session_token: Secret<String>,
+    pub merchant_id: Secret<String>,
+    pub merchant_site_id: Secret<String>,
+    pub time_stamp: String,
+    pub checksum: Secret<String>,
+    pub transaction_id: String,
 }
 
 #[derive(Debug, Default, Serialize, Deserialize)]
@@ -848,9 +851,9 @@ pub struct NuveiACSResponse {
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum LiabilityShift {
-    #[serde(rename = "Y", alias = "1")]
+    #[serde(rename = "Y", alias = "1", alias = "y")]
     Success,
-    #[serde(rename = "N", alias = "0")]
+    #[serde(rename = "N", alias = "0", alias = "n")]
     Failed,
 }
 
@@ -1724,8 +1727,8 @@ where
         let shipping_address: Option<ShippingAddress> =
             item.get_optional_shipping().map(|address| address.into());
 
-        let billing_address: Option<BillingAddress> = address.map(|ref address| address.into());
-
+        let billing_address: Option<BillingAddress> =
+            address.clone().map(|ref address| address.into());
         let device_details = if request_data
             .device_details
             .ip_address
@@ -1902,25 +1905,7 @@ impl TryFrom<(&types::PaymentsCompleteAuthorizeRouterData, Secret<String>)>
                     ..Default::default()
                 })
             }
-            Some(PaymentMethodData::Wallet(..))
-            | Some(PaymentMethodData::PayLater(..))
-            | Some(PaymentMethodData::BankDebit(..))
-            | Some(PaymentMethodData::BankRedirect(..))
-            | Some(PaymentMethodData::BankTransfer(..))
-            | Some(PaymentMethodData::Crypto(..))
-            | Some(PaymentMethodData::MandatePayment)
-            | Some(PaymentMethodData::GiftCard(..))
-            | Some(PaymentMethodData::Voucher(..))
-            | Some(PaymentMethodData::CardRedirect(..))
-            | Some(PaymentMethodData::Reward)
-            | Some(PaymentMethodData::RealTimePayment(..))
-            | Some(PaymentMethodData::MobilePayment(..))
-            | Some(PaymentMethodData::Upi(..))
-            | Some(PaymentMethodData::OpenBanking(_))
-            | Some(PaymentMethodData::CardToken(..))
-            | Some(PaymentMethodData::NetworkToken(..))
-            | Some(PaymentMethodData::CardDetailsForNetworkTransactionId(_))
-            | None => Err(errors::ConnectorError::NotImplemented(
+            _ => Err(errors::ConnectorError::NotImplemented(
                 utils::get_unimplemented_payment_method_error_message("nuvei"),
             )),
         }?;
@@ -1938,7 +1923,7 @@ impl TryFrom<(&types::PaymentsCompleteAuthorizeRouterData, Secret<String>)>
             ..Default::default()
         })?;
         Ok(Self {
-            related_transaction_id: request_data.related_transaction_id,
+            related_transaction_id: item.request.connector_transaction_id.clone(),
             payment_option: request_data.payment_option,
             device_details: request_data.device_details,
             ..request
@@ -2071,9 +2056,33 @@ impl TryFrom<&types::RefundExecuteRouterData> for NuveiPaymentFlowRequest {
 impl TryFrom<&types::PaymentsSyncRouterData> for NuveiPaymentSyncRequest {
     type Error = error_stack::Report<errors::ConnectorError>;
     fn try_from(value: &types::PaymentsSyncRouterData) -> Result<Self, Self::Error> {
-        let meta: NuveiMeta = utils::to_connector_meta(value.request.connector_meta.clone())?;
+        let connector_meta: NuveiAuthType = NuveiAuthType::try_from(&value.connector_auth_type)?;
+        let merchant_id = connector_meta.merchant_id.clone();
+        let merchant_site_id = connector_meta.merchant_site_id.clone();
+        let merchant_secret = connector_meta.merchant_secret.clone();
+        let time_stamp =
+            date_time::format_date(date_time::now(), date_time::DateFormat::YYYYMMDDHHmmss)
+                .change_context(errors::ConnectorError::RequestEncodingFailed)?;
+        let transaction_id = value
+            .request
+            .connector_transaction_id
+            .clone()
+            .get_connector_transaction_id()
+            .change_context(errors::ConnectorError::MissingConnectorTransactionID)?;
+        let checksum = Secret::new(encode_payload(&[
+            merchant_id.peek(),
+            merchant_site_id.peek(),
+            &transaction_id,
+            &time_stamp,
+            merchant_secret.peek(),
+        ])?);
+
         Ok(Self {
-            session_token: meta.session_token,
+            merchant_id,
+            merchant_site_id,
+            time_stamp,
+            checksum,
+            transaction_id,
         })
     }
 }
@@ -2189,11 +2198,17 @@ pub enum NuveiPaymentStatus {
 #[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "UPPERCASE")]
 pub enum NuveiTransactionStatus {
+    #[serde(alias = "Approved", alias = "APPROVED")]
     Approved,
+    #[serde(alias = "Declined", alias = "DECLINED")]
     Declined,
+    #[serde(alias = "Filter Error", alias = "ERROR", alias = "Error")]
     Error,
+    #[serde(alias = "Redirect", alias = "REDIRECT")]
     Redirect,
+    #[serde(alias = "Pending", alias = "PENDING")]
     Pending,
+    #[serde(alias = "Processing", alias = "PROCESSING")]
     #[default]
     Processing,
 }
@@ -2251,35 +2266,105 @@ pub struct NuveiPaymentsResponse {
     pub client_request_id: Option<String>,
     pub merchant_advice_code: Option<String>,
 }
-impl NuveiPaymentsResponse {
-    /// returns amount_captured and minor_amount_capturable
-    pub fn get_amount_captured(
-        &self,
-    ) -> Result<(Option<i64>, Option<MinorUnit>), error_stack::Report<errors::ConnectorError>> {
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NuveiTxnPartialApproval {
+    requested_amount: Option<StringMajorUnit>,
+    requested_currency: Option<enums::Currency>,
+}
+
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NuveiTransactionSyncResponseDetails {
+    gw_error_code: Option<i64>,
+    gw_error_reason: Option<String>,
+    gw_extended_error_code: Option<i64>,
+    transaction_id: Option<String>,
+    transaction_status: Option<NuveiTransactionStatus>,
+    transaction_type: Option<NuveiTransactionType>,
+    auth_code: Option<String>,
+    processed_amount: Option<StringMajorUnit>,
+    processed_currency: Option<enums::Currency>,
+    acquiring_bank_name: Option<String>,
+}
+#[derive(Debug, Clone, Default, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct NuveiTransactionSyncResponse {
+    pub payment_option: Option<PaymentOption>,
+    pub partial_approval: Option<NuveiTxnPartialApproval>,
+    pub is_currency_converted: Option<bool>,
+    pub transaction_details: Option<NuveiTransactionSyncResponseDetails>,
+    pub fraud_details: Option<FraudDetails>,
+    pub client_unique_id: Option<String>,
+    pub internal_request_id: Option<i64>,
+    pub status: NuveiPaymentStatus,
+    pub err_code: Option<i64>,
+    pub reason: Option<String>,
+    pub merchant_id: Option<Secret<String>>,
+    pub merchant_site_id: Option<Secret<String>>,
+    pub version: Option<String>,
+    pub client_request_id: Option<String>,
+    pub merchant_advice_code: Option<String>,
+}
+impl NuveiTransactionSyncResponse {
+    pub fn get_partial_approval(&self) -> Option<NuveiPartialApproval> {
         match &self.partial_approval {
-            Some(partial_approval) => {
-                let amount = utils::convert_back_amount_to_minor_units(
-                    NUVEI_AMOUNT_CONVERTOR,
-                    partial_approval.processed_amount.clone(),
-                    partial_approval.processed_currency,
-                )?;
-                match self.transaction_type {
-                    None => Ok((None, None)),
-                    Some(NuveiTransactionType::Sale) => {
-                        Ok((Some(MinorUnit::get_amount_as_i64(amount)), None))
-                    }
-                    Some(NuveiTransactionType::Auth) => Ok((None, Some(amount))),
-                    Some(NuveiTransactionType::Auth3D) => {
-                        Ok((Some(MinorUnit::get_amount_as_i64(amount)), None))
-                    }
-                    Some(NuveiTransactionType::InitAuth3D) => Ok((None, Some(amount))),
-                    Some(NuveiTransactionType::Credit) => Ok((None, None)),
-                    Some(NuveiTransactionType::Void) => Ok((None, None)),
-                    Some(NuveiTransactionType::Settle) => Ok((None, None)),
+            Some(partial_approval) => match (
+                partial_approval.requested_amount.clone(),
+                partial_approval.requested_currency,
+                self.transaction_details
+                    .as_ref()
+                    .and_then(|txn| txn.processed_amount.clone()),
+                self.transaction_details
+                    .as_ref()
+                    .and_then(|txn| txn.processed_currency),
+            ) {
+                (
+                    Some(requested_amount),
+                    Some(requested_currency),
+                    Some(processed_amount),
+                    Some(processed_currency),
+                ) => Some(NuveiPartialApproval {
+                    requested_amount,
+                    requested_currency,
+                    processed_amount,
+                    processed_currency,
+                }),
+                _ => None,
+            },
+            None => None,
+        }
+    }
+}
+
+pub fn get_amount_captured(
+    partial_approval_data: Option<NuveiPartialApproval>,
+    transaction_type: Option<NuveiTransactionType>,
+) -> Result<(Option<i64>, Option<MinorUnit>), error_stack::Report<errors::ConnectorError>> {
+    match partial_approval_data {
+        Some(partial_approval) => {
+            let amount = utils::convert_back_amount_to_minor_units(
+                NUVEI_AMOUNT_CONVERTOR,
+                partial_approval.processed_amount.clone(),
+                partial_approval.processed_currency,
+            )?;
+            match transaction_type {
+                None => Ok((None, None)),
+                Some(NuveiTransactionType::Sale) => {
+                    Ok((Some(MinorUnit::get_amount_as_i64(amount)), None))
+                }
+                Some(NuveiTransactionType::Auth) => Ok((None, Some(amount))),
+                Some(NuveiTransactionType::Auth3D) => {
+                    Ok((Some(MinorUnit::get_amount_as_i64(amount)), None))
                 }
+                Some(NuveiTransactionType::InitAuth3D) => Ok((None, Some(amount))),
+                Some(NuveiTransactionType::Credit) => Ok((None, None)),
+                Some(NuveiTransactionType::Void) => Ok((None, None)),
+                Some(NuveiTransactionType::Settle) => Ok((None, None)),
             }
-            None => Ok((None, None)),
         }
+        None => Ok((None, None)),
     }
 }
 
@@ -2301,13 +2386,15 @@ pub struct FraudDetails {
 }
 
 fn get_payment_status(
-    response: &NuveiPaymentsResponse,
     amount: Option<i64>,
     is_post_capture_void: bool,
+    transaction_type: Option<NuveiTransactionType>,
+    transaction_status: Option<NuveiTransactionStatus>,
+    status: NuveiPaymentStatus,
 ) -> enums::AttemptStatus {
     // ZERO dollar authorization
-    if amount == Some(0) && response.transaction_type.clone() == Some(NuveiTransactionType::Auth) {
-        return match response.transaction_status.clone() {
+    if amount == Some(0) && transaction_type == Some(NuveiTransactionType::Auth) {
+        return match transaction_status {
             Some(NuveiTransactionStatus::Approved) => enums::AttemptStatus::Charged,
             Some(NuveiTransactionStatus::Declined) | Some(NuveiTransactionStatus::Error) => {
                 enums::AttemptStatus::AuthorizationFailed
@@ -2316,7 +2403,7 @@ fn get_payment_status(
                 enums::AttemptStatus::Pending
             }
             Some(NuveiTransactionStatus::Redirect) => enums::AttemptStatus::AuthenticationPending,
-            None => match response.status {
+            None => match status {
                 NuveiPaymentStatus::Failed | NuveiPaymentStatus::Error => {
                     enums::AttemptStatus::Failure
                 }
@@ -2325,10 +2412,12 @@ fn get_payment_status(
         };
     }
 
-    match response.transaction_status.clone() {
+    match transaction_status {
         Some(status) => match status {
-            NuveiTransactionStatus::Approved => match response.transaction_type {
-                Some(NuveiTransactionType::Auth) => enums::AttemptStatus::Authorized,
+            NuveiTransactionStatus::Approved => match transaction_type {
+                Some(NuveiTransactionType::InitAuth3D) | Some(NuveiTransactionType::Auth) => {
+                    enums::AttemptStatus::Authorized
+                }
                 Some(NuveiTransactionType::Sale) | Some(NuveiTransactionType::Settle) => {
                     enums::AttemptStatus::Charged
                 }
@@ -2336,14 +2425,14 @@ fn get_payment_status(
                     enums::AttemptStatus::VoidedPostCharge
                 }
                 Some(NuveiTransactionType::Void) => enums::AttemptStatus::Voided,
-
+                Some(NuveiTransactionType::Auth3D) => enums::AttemptStatus::AuthenticationPending,
                 _ => enums::AttemptStatus::Pending,
             },
             NuveiTransactionStatus::Declined | NuveiTransactionStatus::Error => {
-                match response.transaction_type {
+                match transaction_type {
                     Some(NuveiTransactionType::Auth) => enums::AttemptStatus::AuthorizationFailed,
                     Some(NuveiTransactionType::Void) => enums::AttemptStatus::VoidFailed,
-                    Some(NuveiTransactionType::Auth3D) => {
+                    Some(NuveiTransactionType::Auth3D) | Some(NuveiTransactionType::InitAuth3D) => {
                         enums::AttemptStatus::AuthenticationFailed
                     }
                     _ => enums::AttemptStatus::Failure,
@@ -2354,37 +2443,49 @@ fn get_payment_status(
             }
             NuveiTransactionStatus::Redirect => enums::AttemptStatus::AuthenticationPending,
         },
-        None => match response.status {
+        None => match status {
             NuveiPaymentStatus::Failed | NuveiPaymentStatus::Error => enums::AttemptStatus::Failure,
             _ => enums::AttemptStatus::Pending,
         },
     }
 }
 
-fn build_error_response(response: &NuveiPaymentsResponse, http_code: u16) -> Option<ErrorResponse> {
-    match response.status {
+#[derive(Debug)]
+struct ErrorResponseParams {
+    http_code: u16,
+    status: NuveiPaymentStatus,
+    err_code: Option<i64>,
+    err_msg: Option<String>,
+    merchant_advice_code: Option<String>,
+    gw_error_code: Option<i64>,
+    gw_error_reason: Option<String>,
+    transaction_status: Option<NuveiTransactionStatus>,
+}
+
+fn build_error_response(params: ErrorResponseParams) -> Option<ErrorResponse> {
+    match params.status {
         NuveiPaymentStatus::Error => Some(get_error_response(
-            response.err_code,
-            &response.reason,
-            http_code,
-            &response.merchant_advice_code,
-            &response.gw_error_code.map(|e| e.to_string()),
-            &response.gw_error_reason,
+            params.err_code,
+            params.err_msg.clone(),
+            params.http_code,
+            params.merchant_advice_code.clone(),
+            params.gw_error_code.map(|code| code.to_string()),
+            params.gw_error_reason.clone(),
         )),
 
         _ => {
             let err = Some(get_error_response(
-                response.gw_error_code,
-                &response.gw_error_reason,
-                http_code,
-                &response.merchant_advice_code,
-                &response.gw_error_code.map(|e| e.to_string()),
-                &response.gw_error_reason,
+                params.gw_error_code,
+                params.gw_error_reason.clone(),
+                params.http_code,
+                params.merchant_advice_code,
+                params.gw_error_code.map(|e| e.to_string()),
+                params.gw_error_reason.clone(),
             ));
 
-            match response.transaction_status {
+            match params.transaction_status {
                 Some(NuveiTransactionStatus::Error) | Some(NuveiTransactionStatus::Declined) => err,
-                _ => match response
+                _ => match params
                     .gw_error_reason
                     .as_ref()
                     .map(|r| r.eq("Missing argument"))
@@ -2433,11 +2534,15 @@ impl
         >,
     ) -> Result<Self, Self::Error> {
         let amount = item.data.request.amount;
+        let response = &item.response;
+        let (status, redirection_data, connector_response_data) = process_nuvei_payment_response(
+            NuveiPaymentResponseData::new(amount, false, item.data.payment_method, response),
+        )?;
 
-        let (status, redirection_data, connector_response_data) =
-            process_nuvei_payment_response(&item, amount, false)?;
-
-        let (amount_captured, minor_amount_capturable) = item.response.get_amount_captured()?;
+        let (amount_captured, minor_amount_capturable) = get_amount_captured(
+            response.partial_approval.clone(),
+            response.transaction_type.clone(),
+        )?;
 
         let ip_address = item
             .data
@@ -2453,16 +2558,31 @@ impl
                 field_name: "browser_info.ip_address",
             })?
             .to_string();
+        let response = &item.response;
 
         Ok(Self {
             status,
-            response: if let Some(err) = build_error_response(&item.response, item.http_code) {
+            response: if let Some(err) = build_error_response(ErrorResponseParams {
+                http_code: item.http_code,
+                status: response.status.clone(),
+                err_code: response.err_code,
+                err_msg: response.reason.clone(),
+                merchant_advice_code: response.merchant_advice_code.clone(),
+                gw_error_code: response.gw_error_code,
+                gw_error_reason: response.gw_error_reason.clone(),
+                transaction_status: response.transaction_status.clone(),
+            }) {
                 Err(err)
             } else {
+                let response = &item.response;
                 Ok(create_transaction_response(
-                    &item.response,
                     redirection_data,
                     Some(ip_address),
+                    response.transaction_id.clone(),
+                    response.order_id.clone(),
+                    response.session_token.clone(),
+                    response.external_scheme_transaction_id.clone(),
+                    response.payment_option.clone(),
                 )?)
             },
             amount_captured,
@@ -2475,10 +2595,64 @@ impl
 
 // Helper function to process Nuvei payment response
 
-fn process_nuvei_payment_response<F, T>(
-    item: &ResponseRouterData<F, NuveiPaymentsResponse, T, PaymentsResponseData>,
-    amount: Option<i64>,
-    is_post_capture_void: bool,
+/// Struct to encapsulate parameters for processing Nuvei payment responses
+#[derive(Debug)]
+pub struct NuveiPaymentResponseData {
+    pub amount: Option<i64>,
+    pub is_post_capture_void: bool,
+    pub payment_method: enums::PaymentMethod,
+    pub payment_option: Option<PaymentOption>,
+    pub transaction_type: Option<NuveiTransactionType>,
+    pub transaction_status: Option<NuveiTransactionStatus>,
+    pub status: NuveiPaymentStatus,
+    pub merchant_advice_code: Option<String>,
+}
+
+impl NuveiPaymentResponseData {
+    pub fn new(
+        amount: Option<i64>,
+        is_post_capture_void: bool,
+        payment_method: enums::PaymentMethod,
+        response: &NuveiPaymentsResponse,
+    ) -> Self {
+        Self {
+            amount,
+            is_post_capture_void,
+            payment_method,
+            payment_option: response.payment_option.clone(),
+            transaction_type: response.transaction_type.clone(),
+            transaction_status: response.transaction_status.clone(),
+            status: response.status.clone(),
+            merchant_advice_code: response.merchant_advice_code.clone(),
+        }
+    }
+
+    pub fn new_from_sync_response(
+        amount: Option<i64>,
+        is_post_capture_void: bool,
+        payment_method: enums::PaymentMethod,
+        response: &NuveiTransactionSyncResponse,
+    ) -> Self {
+        let transaction_details = &response.transaction_details;
+        Self {
+            amount,
+            is_post_capture_void,
+            payment_method,
+            payment_option: response.payment_option.clone(),
+            transaction_type: transaction_details
+                .as_ref()
+                .and_then(|details| details.transaction_type.clone()),
+            transaction_status: transaction_details
+                .as_ref()
+                .and_then(|details| details.transaction_status.clone()),
+            status: response.status.clone(),
+            merchant_advice_code: None,
+        }
+    }
+}
+
+fn process_nuvei_payment_response(
+    data: NuveiPaymentResponseData,
 ) -> Result<
     (
         enums::AttemptStatus,
@@ -2486,20 +2660,14 @@ fn process_nuvei_payment_response<F, T>(
         Option<ConnectorResponseData>,
     ),
     error_stack::Report<errors::ConnectorError>,
->
-where
-    F: std::fmt::Debug,
-    T: std::fmt::Debug,
-{
-    let redirection_data = match item.data.payment_method {
-        enums::PaymentMethod::Wallet | enums::PaymentMethod::BankRedirect => item
-            .response
+> {
+    let redirection_data = match data.payment_method {
+        enums::PaymentMethod::Wallet | enums::PaymentMethod::BankRedirect => data
             .payment_option
             .as_ref()
             .and_then(|po| po.redirect_url.clone())
             .map(|base_url| RedirectForm::from((base_url, Method::Get))),
-        _ => item
-            .response
+        _ => data
             .payment_option
             .as_ref()
             .and_then(|o| o.card.clone())
@@ -2511,32 +2679,42 @@ where
                 form_fields: std::collections::HashMap::from([("creq".to_string(), creq.expose())]),
             }),
     };
-    let connector_response_data =
-        convert_to_additional_payment_method_connector_response(&item.response)
-            .map(ConnectorResponseData::with_additional_payment_method_data);
 
-    let status = get_payment_status(&item.response, amount, is_post_capture_void);
+    let connector_response_data = convert_to_additional_payment_method_connector_response(
+        data.payment_option.clone(),
+        data.merchant_advice_code,
+    )
+    .map(ConnectorResponseData::with_additional_payment_method_data);
+    let status = get_payment_status(
+        data.amount,
+        data.is_post_capture_void,
+        data.transaction_type,
+        data.transaction_status,
+        data.status,
+    );
 
     Ok((status, redirection_data, connector_response_data))
 }
 
 // Helper function to create transaction response
 fn create_transaction_response(
-    response: &NuveiPaymentsResponse,
     redirection_data: Option<RedirectForm>,
     ip_address: Option<String>,
+    transaction_id: Option<String>,
+    order_id: Option<String>,
+    session_token: Option<Secret<String>>,
+    external_scheme_transaction_id: Option<Secret<String>>,
+    payment_option: Option<PaymentOption>,
 ) -> Result<PaymentsResponseData, error_stack::Report<errors::ConnectorError>> {
     Ok(PaymentsResponseData::TransactionResponse {
-        resource_id: response
-            .transaction_id
+        resource_id: transaction_id
             .clone()
-            .map_or(response.order_id.clone(), Some) // For paypal there will be no transaction_id, only order_id will be present
+            .map_or(order_id.clone(), Some) // For paypal there will be no transaction_id, only order_id will be present
             .map(ResponseId::ConnectorTransactionId)
             .ok_or(errors::ConnectorError::MissingConnectorTransactionID)?,
         redirection_data: Box::new(redirection_data),
         mandate_reference: Box::new(
-            response
-                .payment_option
+            payment_option
                 .as_ref()
                 .and_then(|po| po.user_payment_option_id.clone())
                 .map(|id| MandateReference {
@@ -2548,7 +2726,7 @@ fn create_transaction_response(
                 }),
         ),
         // we don't need to save session token for capture, void flow so ignoring if it is not present
-        connector_metadata: if let Some(token) = response.session_token.clone() {
+        connector_metadata: if let Some(token) = session_token {
             Some(
                 serde_json::to_value(NuveiMeta {
                     session_token: token,
@@ -2558,11 +2736,10 @@ fn create_transaction_response(
         } else {
             None
         },
-        network_txn_id: response
-            .external_scheme_transaction_id
+        network_txn_id: external_scheme_transaction_id
             .as_ref()
             .map(|ntid| ntid.clone().expose()),
-        connector_response_reference_id: response.order_id.clone(),
+        connector_response_reference_id: order_id.clone(),
         incremental_authorization_allowed: None,
         charges: None,
     })
@@ -2590,11 +2767,15 @@ impl
     ) -> Result<Self, Self::Error> {
         // Get amount directly from the authorize data
         let amount = Some(item.data.request.amount);
+        let response = &item.response;
+        let (status, redirection_data, connector_response_data) = process_nuvei_payment_response(
+            NuveiPaymentResponseData::new(amount, false, item.data.payment_method, response),
+        )?;
 
-        let (status, redirection_data, connector_response_data) =
-            process_nuvei_payment_response(&item, amount, false)?;
-
-        let (amount_captured, minor_amount_capturable) = item.response.get_amount_captured()?;
+        let (amount_captured, minor_amount_capturable) = get_amount_captured(
+            response.partial_approval.clone(),
+            response.transaction_type.clone(),
+        )?;
 
         let ip_address = item
             .data
@@ -2605,13 +2786,27 @@ impl
 
         Ok(Self {
             status,
-            response: if let Some(err) = build_error_response(&item.response, item.http_code) {
+            response: if let Some(err) = build_error_response(ErrorResponseParams {
+                http_code: item.http_code,
+                status: response.status.clone(),
+                err_code: response.err_code,
+                err_msg: response.reason.clone(),
+                merchant_advice_code: response.merchant_advice_code.clone(),
+                gw_error_code: response.gw_error_code,
+                gw_error_reason: response.gw_error_reason.clone(),
+                transaction_status: response.transaction_status.clone(),
+            }) {
                 Err(err)
             } else {
+                let response = &item.response;
                 Ok(create_transaction_response(
-                    &item.response,
                     redirection_data,
                     ip_address,
+                    response.transaction_id.clone(),
+                    response.order_id.clone(),
+                    response.session_token.clone(),
+                    response.external_scheme_transaction_id.clone(),
+                    response.payment_option.clone(),
                 )?)
             },
             amount_captured,
@@ -2638,19 +2833,113 @@ where
             .data
             .minor_amount_capturable
             .map(|amount| amount.get_amount_as_i64());
+        let response = &item.response;
         let (status, redirection_data, connector_response_data) =
-            process_nuvei_payment_response(&item, amount, F::is_post_capture_void())?;
+            process_nuvei_payment_response(NuveiPaymentResponseData::new(
+                amount,
+                F::is_post_capture_void(),
+                item.data.payment_method,
+                response,
+            ))?;
+
+        let (amount_captured, minor_amount_capturable) = get_amount_captured(
+            response.partial_approval.clone(),
+            response.transaction_type.clone(),
+        )?;
+        Ok(Self {
+            status,
+            response: if let Some(err) = build_error_response(ErrorResponseParams {
+                http_code: item.http_code,
+                status: response.status.clone(),
+                err_code: response.err_code,
+                err_msg: response.reason.clone(),
+                merchant_advice_code: response.merchant_advice_code.clone(),
+                gw_error_code: response.gw_error_code,
+                gw_error_reason: response.gw_error_reason.clone(),
+                transaction_status: response.transaction_status.clone(),
+            }) {
+                Err(err)
+            } else {
+                let response = &item.response;
+                Ok(create_transaction_response(
+                    redirection_data,
+                    None,
+                    response.transaction_id.clone(),
+                    response.order_id.clone(),
+                    response.session_token.clone(),
+                    response.external_scheme_transaction_id.clone(),
+                    response.payment_option.clone(),
+                )?)
+            },
+            amount_captured,
+            minor_amount_capturable,
+            connector_response: connector_response_data,
+            ..item.data
+        })
+    }
+}
 
-        let (amount_captured, minor_amount_capturable) = item.response.get_amount_captured()?;
+// Generic implementation for other flow types
+impl<F, T> TryFrom<ResponseRouterData<F, NuveiTransactionSyncResponse, T, PaymentsResponseData>>
+    for RouterData<F, T, PaymentsResponseData>
+where
+    F: NuveiPaymentsGenericResponse + std::fmt::Debug,
+    T: std::fmt::Debug,
+    F: std::any::Any,
+{
+    type Error = error_stack::Report<errors::ConnectorError>;
+    fn try_from(
+        item: ResponseRouterData<F, NuveiTransactionSyncResponse, T, PaymentsResponseData>,
+    ) -> Result<Self, Self::Error> {
+        let amount = item
+            .data
+            .minor_amount_capturable
+            .map(|amount| amount.get_amount_as_i64());
+        let response = &item.response;
+        let transaction_details = &response.transaction_details;
+        let transaction_type = transaction_details
+            .as_ref()
+            .and_then(|details| details.transaction_type.clone());
+        let (status, redirection_data, connector_response_data) =
+            process_nuvei_payment_response(NuveiPaymentResponseData::new_from_sync_response(
+                amount,
+                F::is_post_capture_void(),
+                item.data.payment_method,
+                response,
+            ))?;
+
+        let (amount_captured, minor_amount_capturable) =
+            get_amount_captured(response.get_partial_approval(), transaction_type.clone())?;
         Ok(Self {
             status,
-            response: if let Some(err) = build_error_response(&item.response, item.http_code) {
+            response: if let Some(err) = build_error_response(ErrorResponseParams {
+                http_code: item.http_code,
+                status: response.status.clone(),
+                err_code: response.err_code,
+                err_msg: response.reason.clone(),
+                merchant_advice_code: None,
+                gw_error_code: transaction_details
+                    .as_ref()
+                    .and_then(|details| details.gw_error_code),
+                gw_error_reason: transaction_details
+                    .as_ref()
+                    .and_then(|details| details.gw_error_reason.clone()),
+                transaction_status: transaction_details
+                    .as_ref()
+                    .and_then(|details| details.transaction_status.clone()),
+            }) {
                 Err(err)
             } else {
                 Ok(create_transaction_response(
-                    &item.response,
                     redirection_data,
                     None,
+                    transaction_details
+                        .as_ref()
+                        .and_then(|data| data.transaction_id.clone()),
+                    None,
+                    None,
+                    None,
+                    response.payment_option.clone(),
                 )?)
             },
             amount_captured,
@@ -2678,12 +2967,17 @@ impl TryFrom<PaymentsPreprocessingResponseRouterData<NuveiPaymentsResponse>>
             .map(to_boolean)
             .unwrap_or_default();
         Ok(Self {
-            status: get_payment_status(&response, item.data.request.amount, false),
+            status: get_payment_status(
+                item.data.request.amount,
+                false,
+                response.transaction_type,
+                response.transaction_status,
+                response.status,
+            ),
             response: Ok(PaymentsResponseData::ThreeDSEnrollmentResponse {
                 enrolled_v2: is_enrolled_for_3ds,
                 related_transaction_id: response.transaction_id,
             }),
-
             ..item.data
         })
     }
@@ -2760,11 +3054,7 @@ where
                 .request
                 .get_customer_id_required()
                 .ok_or(missing_field_err("customer_id")())?;
-            let related_transaction_id = if item.is_three_ds() {
-                item.request.get_related_transaction_id().clone()
-            } else {
-                None
-            };
+            let related_transaction_id = item.request.get_related_transaction_id().clone();
 
             let ip_address = data
                 .recurring_mandate_payment_data
@@ -2823,20 +3113,20 @@ fn get_refund_response(
     match response.status {
         NuveiPaymentStatus::Error => Err(Box::new(get_error_response(
             response.err_code,
-            &response.reason,
+            response.reason.clone(),
             http_code,
-            &response.merchant_advice_code,
-            &response.gw_error_code.map(|e| e.to_string()),
-            &response.gw_error_reason,
+            response.merchant_advice_code,
+            response.gw_error_code.map(|e| e.to_string()),
+            response.gw_error_reason,
         ))),
         _ => match response.transaction_status {
             Some(NuveiTransactionStatus::Error) => Err(Box::new(get_error_response(
                 response.err_code,
-                &response.reason,
+                response.reason,
                 http_code,
-                &response.merchant_advice_code,
-                &response.gw_error_code.map(|e| e.to_string()),
-                &response.gw_error_reason,
+                response.merchant_advice_code,
+                response.gw_error_code.map(|e| e.to_string()),
+                response.gw_error_reason,
             ))),
             _ => Ok(RefundsResponseData {
                 connector_refund_id: txn_id,
@@ -2848,11 +3138,11 @@ fn get_refund_response(
 
 fn get_error_response(
     error_code: Option<i64>,
-    error_msg: &Option<String>,
+    error_msg: Option<String>,
     http_code: u16,
-    network_advice_code: &Option<String>,
-    network_decline_code: &Option<String>,
-    network_error_message: &Option<String>,
+    network_advice_code: Option<String>,
+    network_decline_code: Option<String>,
+    network_error_message: Option<String>,
 ) -> ErrorResponse {
     ErrorResponse {
         code: error_code
@@ -3049,6 +3339,7 @@ impl From<NuveiWebhook> for NuveiPaymentsResponse {
                         TransactionStatus::Declined => NuveiTransactionStatus::Declined,
                         TransactionStatus::Error => NuveiTransactionStatus::Error,
                         TransactionStatus::Settled => NuveiTransactionStatus::Approved,
+
                         _ => NuveiTransactionStatus::Processing,
                     }),
                     transaction_id: notification.transaction_id,
@@ -3116,21 +3407,17 @@ pub fn concat_strings(strings: &[String]) -> String {
 }
 
 fn convert_to_additional_payment_method_connector_response(
-    transaction_response: &NuveiPaymentsResponse,
+    payment_option: Option<PaymentOption>,
+    merchant_advice_code: Option<String>,
 ) -> Option<AdditionalPaymentMethodConnectorResponse> {
-    let card = transaction_response
-        .payment_option
-        .as_ref()?
-        .card
-        .as_ref()?;
+    let card = payment_option.as_ref()?.card.as_ref()?;
     let avs_code = card.avs_code.as_ref();
     let cvv2_code = card.cvv2_reply.as_ref();
-    let merchant_advice_code = transaction_response.merchant_advice_code.as_ref();
-
     let avs_description = avs_code.and_then(|code| get_avs_response_description(code));
     let cvv_description = cvv2_code.and_then(|code| get_cvv2_response_description(code));
-    let merchant_advice_description =
-        merchant_advice_code.and_then(|code| get_merchant_advice_code_description(code));
+    let merchant_advice_description = merchant_advice_code
+        .as_ref()
+        .and_then(|code| get_merchant_advice_code_description(code));
 
     let payment_checks = serde_json::json!({
         "avs_result": avs_code,

## Type of Change
<!-- Put an `x` in the boxes that apply -->

- [x] Bugfix
- [ ] New feature
- [ ] Enhancement
- [ ] Refactoring
- [ ] Dependency updates
- [ ] Documentation
- [ ] CI/CD

## Description
<!-- Describe your changes in detail -->

- 3ds transaction were not actually 3ds transactions in Nuvei system. This occurred because we were not passing previous transaction data while making 3ds complete-authorize call.
- Prevoiusly psync was implemeted with session token. If we make 3ds payment but not confirm and make psycn the nuvei would return error as session transaction not found. Now we have implemented psync with transaction_id .

## TEST 

### Trigger 3ds payment

<details>
  <summary> Request </summary> 

```json
{
    "amount": 15100,
    "currency": "EUR",
    "confirm": true,
    "customer_acceptance": {
        "acceptance_type": "online",
        "accepted_at": "1963-05-03T04:07:52.723Z",
        "online": {
            "ip_address": "in sit",
            "user_agent": "amet irure esse"
        }
    },
    // "order_tax_amount": 100,
    "setup_future_usage": "off_session",
    // "payment_type":"setup_mandate",
    "customer_id": "nithxxinn",
    "return_url": "https://www.google.com",
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_type": "credit",
    "authentication_type": "three_ds",
    "description": "hellow world",
    "billing": {
        "address": {
            "zip": "560095",
            "country": "US",
            "first_name": "Sakil",
            "last_name": "Mostak",
            "line1": "Fasdf",
            "line2": "Fasdf",
            "city": "Fasdf"
        }
    },
    "browser_info": {
        "accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "ip_address": "192.168.1.1",
        "java_enabled": false,
        "java_script_enabled": true,
        "language": "en-US",
        "color_depth": 24,
        "screen_height": 1080,
        "screen_width": 1920,
        "time_zone": 330,
        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36"
    },
    "email": "hello@gmail.com",
    "payment_method_data": {
        "card": {
            "card_number": "2221008123677736",
            "card_exp_month": "01",
            "card_exp_year": "2026",
            "card_holder_name": "CL-BRW2",
            "card_cvc": "100"
        }
    }
}
```

</details>



<details>
  <summary> Response  </summary> 

```
{
    "payment_id": "pay_wiZYcVFqfCNBOJMEpznT",
    "merchant_id": "merchant_1756789409",
    "status": "requires_customer_action",
    "amount": 15100,
    "net_amount": 15100,
    "shipping_cost": null,
    "amount_capturable": 15100,
    "amount_received": null,
    "connector": "nuvei",
    "client_secret": "pay_wiZYcVFqfCNBOJMEpznT_secret_GiNUpAUyDpT4rK5COmn9",
    "created": "2025-09-10T05:09:57.712Z",
    "currency": "EUR",
    "customer_id": "nithxxinn",
    "customer": {
        "id": "nithxxinn",
        "name": null,
        "email": "hello@gmail.com",
        "phone": null,
        "phone_country_code": null
    },
    "description": "hellow world",
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": "off_session",
    "off_session": null,
    "capture_on": null,
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_data": {
        "card": {
            "last4": "7736",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "222100",
            "card_extended_bin": null,
            "card_exp_month": "01",
            "card_exp_year": "2026",
            "card_holder_name": "CL-BRW2",
            "payment_checks": {
                "avs_description": null,
                "avs_result_code": "",
                "cvv_2_reply_code": "",
                "cvv_2_description": null,
                "merchant_advice_code": "",
                "merchant_advice_code_description": null
            },
            "authentication_data": {
                "cReq": "eyJ0aHJlZURTU2VydmVyVHJhbnNJRCI6IjE4MWEzOTQ4LWI5ZmYtNGMyZi05ODJkLTAzOTU1OTYzMjhjMSIsImFjc1RyYW5zSUQiOiIwMjcwOTg4OC0xNWIxLTRjOWMtYTA2OC04ZWVlMTBlZmRlODIiLCJjaGFsbGVuZ2VXaW5kb3dTaXplIjoiMDUiLCJtZXNzYWdlVHlwZSI6IkNSZXEiLCJtZXNzYWdlVmVyc2lvbiI6IjIuMi4wIn0",
                "flow": "challenge",
                "acsUrl": "https://3dsn.sandbox.safecharge.com/ThreeDSACSEmulatorChallenge/api/ThreeDSACSChallengeController/ChallengePage?eyJub3RpZmljYXRpb25VUkwiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvcGF5bWVudHMvcGF5X3dpWlljVkZxZkNOQk9KTUVwem5UL21lcmNoYW50XzE3NTY3ODk0MDkvcmVkaXJlY3QvY29tcGxldGUvbnV2ZWkiLCJ0aHJlZURTU2VydmVyVHJhbnNJRCI6IjE4MWEzOTQ4LWI5ZmYtNGMyZi05ODJkLTAzOTU1OTYzMjhjMSIsImFjc1RyYW5zSUQiOiIwMjcwOTg4OC0xNWIxLTRjOWMtYTA2OC04ZWVlMTBlZmRlODIiLCJkc1RyYW5zSUQiOiJmMmRhYTg2Yi1kZWM2LTQ0ZmItODQzMC0zNGI4ZGFhZGVlMjAiLCJkYXRhIjpudWxsLCJNZXNzYWdlVmVyc2lvbiI6IjIuMi4wIn0=",
                "version": "2.2.0",
                "threeDFlow": "1",
                "decisionReason": "NoPreference",
                "threeDReasonId": "",
                "acquirerDecision": "ExemptionRequest",
                "challengePreferenceReason": "12",
                "isExemptionRequestInAuthentication": "0"
            }
        },
        "billing": null
    },
    "payment_token": "token_zab9VyBWQCNOWzesgwEe",
    "shipping": null,
    "billing": {
        "address": {
            "city": "Fasdf",
            "country": "US",
            "line1": "Fasdf",
            "line2": "Fasdf",
            "line3": null,
            "zip": "560095",
            "state": null,
            "first_name": "Sakil",
            "last_name": "Mostak",
            "origin_zip": null
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "hello@gmail.com",
    "name": null,
    "phone": null,
    "return_url": "https://www.google.com/",
    "authentication_type": "three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": {
        "type": "redirect_to_url",
        "redirect_to_url": "http://localhost:8080/payments/redirect/pay_wiZYcVFqfCNBOJMEpznT/merchant_1756789409/pay_wiZYcVFqfCNBOJMEpznT_1"
    },
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "credit",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": {
        "customer_id": "nithxxinn",
        "created_at": 1757480997,
        "expires": 1757484597,
        "secret": "epk_f4e147f4736a41c0bf152be511495bd2"
    },
    "manual_retry_allowed": null,
    "connector_transaction_id": "8110000000013946637",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": {
        "redirect_response": null,
        "search_tags": null,
        "apple_pay_recurring_details": null,
        "gateway_system": "direct"
    },
    "reference_id": "8656791111",
    "payment_link": null,
    "profile_id": "pro_EzO6xGQZdE5pd9I5Rdzs",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_i5QVCDvXmBLbZg7n97n2",
    "incremental_authorization_allowed": false,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2025-09-10T05:24:57.712Z",
    "fingerprint": null,
    "browser_info": {
        "language": "en-US",
        "time_zone": 330,
        "ip_address": "192.168.1.1",
        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
        "color_depth": 24,
        "java_enabled": false,
        "screen_width": 1920,
        "accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "screen_height": 1080,
        "java_script_enabled": true
    },
    "payment_channel": null,
    "payment_method_id": "pm_PNtSuuIcOnjnfMyAoL8x",
    "network_transaction_id": null,
    "payment_method_status": "inactive",
    "updated": "2025-09-10T05:10:01.440Z",
    "split_payments": null,
    "frm_metadata": null,
    "extended_authorization_applied": null,
    "capture_before": null,
    "merchant_order_reference_id": null,
    "order_tax_amount": null,
    "connector_mandate_id": "2090421111",
    "card_discovery": "manual",
    "force_3ds_challenge": false,
    "force_3ds_challenge_trigger": false,
    "issuer_error_code": null,
    "issuer_error_message": null,
    "is_iframe_redirection_enabled": null,
    "whole_connector_response": null,
    "enable_partial_authorization": null
}
```

</details>

- connector_transaction_id = `8110000000013946637` 

### Make psync Before redirection 

<details>
  <summary>Response  </summary> 

```json
{
    "payment_id": "pay_wiZYcVFqfCNBOJMEpznT",
    "merchant_id": "merchant_1756789409",
    "status": "requires_customer_action",
    "amount": 15100,
    "net_amount": 15100,
    "shipping_cost": null,
    "amount_capturable": 15100,
    "amount_received": null,
    "connector": "nuvei",
    "client_secret": "pay_wiZYcVFqfCNBOJMEpznT_secret_GiNUpAUyDpT4rK5COmn9",
    "created": "2025-09-10T05:09:57.712Z",
    "currency": "EUR",
    "customer_id": "nithxxinn",
    "customer": {
        "id": "nithxxinn",
        "name": null,
        "email": "hello@gmail.com",
        "phone": null,
        "phone_country_code": null
    },
    "description": "hellow world",
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": "off_session",
    "off_session": null,
    "capture_on": null,
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_data": {
        "card": {
            "last4": "7736",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "222100",
            "card_extended_bin": null,
            "card_exp_month": "01",
            "card_exp_year": "2026",
            "card_holder_name": "CL-BRW2",
            "payment_checks": {
                "avs_description": null,
                "avs_result_code": "",
                "cvv_2_reply_code": "",
                "cvv_2_description": null,
                "merchant_advice_code": "",
                "merchant_advice_code_description": null
            },
            "authentication_data": {
                "cReq": "eyJ0aHJlZURTU2VydmVyVHJhbnNJRCI6IjE4MWEzOTQ4LWI5ZmYtNGMyZi05ODJkLTAzOTU1OTYzMjhjMSIsImFjc1RyYW5zSUQiOiIwMjcwOTg4OC0xNWIxLTRjOWMtYTA2OC04ZWVlMTBlZmRlODIiLCJjaGFsbGVuZ2VXaW5kb3dTaXplIjoiMDUiLCJtZXNzYWdlVHlwZSI6IkNSZXEiLCJtZXNzYWdlVmVyc2lvbiI6IjIuMi4wIn0",
                "flow": "challenge",
                "acsUrl": "https://3dsn.sandbox.safecharge.com/ThreeDSACSEmulatorChallenge/api/ThreeDSACSChallengeController/ChallengePage?eyJub3RpZmljYXRpb25VUkwiOiJodHRwOi8vbG9jYWxob3N0OjgwODAvcGF5bWVudHMvcGF5X3dpWlljVkZxZkNOQk9KTUVwem5UL21lcmNoYW50XzE3NTY3ODk0MDkvcmVkaXJlY3QvY29tcGxldGUvbnV2ZWkiLCJ0aHJlZURTU2VydmVyVHJhbnNJRCI6IjE4MWEzOTQ4LWI5ZmYtNGMyZi05ODJkLTAzOTU1OTYzMjhjMSIsImFjc1RyYW5zSUQiOiIwMjcwOTg4OC0xNWIxLTRjOWMtYTA2OC04ZWVlMTBlZmRlODIiLCJkc1RyYW5zSUQiOiJmMmRhYTg2Yi1kZWM2LTQ0ZmItODQzMC0zNGI4ZGFhZGVlMjAiLCJkYXRhIjpudWxsLCJNZXNzYWdlVmVyc2lvbiI6IjIuMi4wIn0=",
                "version": "2.2.0",
                "threeDFlow": "1",
                "decisionReason": "NoPreference",
                "threeDReasonId": "",
                "acquirerDecision": "ExemptionRequest",
                "challengePreferenceReason": "12",
                "isExemptionRequestInAuthentication": "0"
            }
        },
        "billing": null
    },
    "payment_token": "token_zab9VyBWQCNOWzesgwEe",
    "shipping": null,
    "billing": {
        "address": {
            "city": "Fasdf",
            "country": "US",
            "line1": "Fasdf",
            "line2": "Fasdf",
            "line3": null,
            "zip": "560095",
            "state": null,
            "first_name": "Sakil",
            "last_name": "Mostak",
            "origin_zip": null
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "hello@gmail.com",
    "name": null,
    "phone": null,
    "return_url": "https://www.google.com/",
    "authentication_type": "three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": {
        "type": "redirect_to_url",
        "redirect_to_url": "http://localhost:8080/payments/redirect/pay_wiZYcVFqfCNBOJMEpznT/merchant_1756789409/pay_wiZYcVFqfCNBOJMEpznT_1"
    },
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "credit",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": null,
    "manual_retry_allowed": null,
    "connector_transaction_id": "8110000000013946637",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": {
        "redirect_response": null,
        "search_tags": null,
        "apple_pay_recurring_details": null,
        "gateway_system": "direct"
    },
    "reference_id": "8656791111",
    "payment_link": null,
    "profile_id": "pro_EzO6xGQZdE5pd9I5Rdzs",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_i5QVCDvXmBLbZg7n97n2",
    "incremental_authorization_allowed": false,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2025-09-10T05:24:57.712Z",
    "fingerprint": null,
    "browser_info": {
        "language": "en-US",
        "time_zone": 330,
        "ip_address": "192.168.1.1",
        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
        "color_depth": 24,
        "java_enabled": false,
        "screen_width": 1920,
        "accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "screen_height": 1080,
        "java_script_enabled": true
    },
    "payment_channel": null,
    "payment_method_id": "pm_PNtSuuIcOnjnfMyAoL8x",
    "network_transaction_id": null,
    "payment_method_status": "inactive",
    "updated": "2025-09-10T05:11:10.384Z",
    "split_payments": null,
    "frm_metadata": null,
    "extended_authorization_applied": null,
    "capture_before": null,
    "merchant_order_reference_id": null,
    "order_tax_amount": null,
    "connector_mandate_id": "2090421111",
    "card_discovery": "manual",
    "force_3ds_challenge": false,
    "force_3ds_challenge_trigger": false,
    "issuer_error_code": null,
    "issuer_error_message": null,
    "is_iframe_redirection_enabled": null,
    "whole_connector_response": null,
    "enable_partial_authorization": null
}
```

</details>

### Complete redirection challenge



### Check Psync again

<details>
  <summary>Response  </summary> 

```json
{
    "payment_id": "pay_wiZYcVFqfCNBOJMEpznT",
    "merchant_id": "merchant_1756789409",
    "status": "succeeded",
    "amount": 15100,
    "net_amount": 15100,
    "shipping_cost": null,
    "amount_capturable": 0,
    "amount_received": 15100,
    "connector": "nuvei",
    "client_secret": "pay_wiZYcVFqfCNBOJMEpznT_secret_GiNUpAUyDpT4rK5COmn9",
    "created": "2025-09-10T05:09:57.712Z",
    "currency": "EUR",
    "customer_id": "nithxxinn",
    "customer": {
        "id": "nithxxinn",
        "name": null,
        "email": "hello@gmail.com",
        "phone": null,
        "phone_country_code": null
    },
    "description": "hellow world",
    "refunds": null,
    "disputes": null,
    "mandate_id": null,
    "mandate_data": null,
    "setup_future_usage": "off_session",
    "off_session": null,
    "capture_on": null,
    "capture_method": "automatic",
    "payment_method": "card",
    "payment_method_data": {
        "card": {
            "last4": "7736",
            "card_type": null,
            "card_network": null,
            "card_issuer": null,
            "card_issuing_country": null,
            "card_isin": "222100",
            "card_extended_bin": null,
            "card_exp_month": "01",
            "card_exp_year": "2026",
            "card_holder_name": "CL-BRW2",
            "payment_checks": {
                "avs_description": null,
                "avs_result_code": "",
                "cvv_2_reply_code": "",
                "cvv_2_description": null,
                "merchant_advice_code": "",
                "merchant_advice_code_description": null
            },
            "authentication_data": {
                "flow": "challenge",
                "version": "2.2.0",
                "decisionReason": "NoPreference",
                "threeDReasonId": "",
                "acquirerDecision": "ExemptionRequest",
                "isLiabilityOnIssuer": "1",
                "challengeCancelReason": "",
                "challengeCancelReasonId": "",
                "challengePreferenceReason": "12"
            }
        },
        "billing": null
    },
    "payment_token": "token_zab9VyBWQCNOWzesgwEe",
    "shipping": null,
    "billing": {
        "address": {
            "city": "Fasdf",
            "country": "US",
            "line1": "Fasdf",
            "line2": "Fasdf",
            "line3": null,
            "zip": "560095",
            "state": null,
            "first_name": "Sakil",
            "last_name": "Mostak",
            "origin_zip": null
        },
        "phone": null,
        "email": null
    },
    "order_details": null,
    "email": "hello@gmail.com",
    "name": null,
    "phone": null,
    "return_url": "https://www.google.com/",
    "authentication_type": "three_ds",
    "statement_descriptor_name": null,
    "statement_descriptor_suffix": null,
    "next_action": null,
    "cancellation_reason": null,
    "error_code": null,
    "error_message": null,
    "unified_code": null,
    "unified_message": null,
    "payment_experience": null,
    "payment_method_type": "credit",
    "connector_label": null,
    "business_country": null,
    "business_label": "default",
    "business_sub_label": null,
    "allowed_payment_method_types": null,
    "ephemeral_key": null,
    "manual_retry_allowed": false,
    "connector_transaction_id": "8110000000013946718",
    "frm_message": null,
    "metadata": null,
    "connector_metadata": null,
    "feature_metadata": {
        "redirect_response": null,
        "search_tags": null,
        "apple_pay_recurring_details": null,
        "gateway_system": "direct"
    },
    "reference_id": "8656791111",
    "payment_link": null,
    "profile_id": "pro_EzO6xGQZdE5pd9I5Rdzs",
    "surcharge_details": null,
    "attempt_count": 1,
    "merchant_decision": null,
    "merchant_connector_id": "mca_i5QVCDvXmBLbZg7n97n2",
    "incremental_authorization_allowed": false,
    "authorization_count": null,
    "incremental_authorizations": null,
    "external_authentication_details": null,
    "external_3ds_authentication_attempted": false,
    "expires_on": "2025-09-10T05:24:57.712Z",
    "fingerprint": null,
    "browser_info": {
        "language": "en-US",
        "time_zone": 330,
        "ip_address": "192.168.1.1",
        "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
        "color_depth": 24,
        "java_enabled": false,
        "screen_width": 1920,
        "accept_header": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
        "screen_height": 1080,
        "java_script_enabled": true
    },
    "payment_channel": null,
    "payment_method_id": "pm_PNtSuuIcOnjnfMyAoL8x",
    "network_transaction_id": null,
    "payment_method_status": "active",
    "updated": "2025-09-10T05:11:56.957Z",
    "split_payments": null,
    "frm_metadata": null,
    "extended_authorization_applied": null,
    "capture_before": null,
    "merchant_order_reference_id": null,
    "order_tax_amount": null,
    "connector_mandate_id": null,
    "card_discovery": "manual",
    "force_3ds_challenge": false,
    "force_3ds_challenge_trigger": false,
    "issuer_error_code": null,
    "issuer_error_message": null,
    "is_iframe_redirection_enabled": null,
    "whole_connector_response": null,
    "enable_partial_authorization": null
}
```
</details>

- connector_transaction_id :  `8110000000013946718`

### Check transaction in nuvei dashboard for complete validation

<img width="1857" height="938" alt="Screenshot 2025-09-10 at 10 43 50 AM" src="https://github.com/user-attachments/assets/2985795f-8c0b-43d8-a58f-fecd59af3273" />
<img width="1761" height="859" alt="Screenshot 2025-09-10 at 10 44 16 AM" src="https://github.com/user-attachments/assets/7d2436df-1004-4de0-b1e3-d6fcfb83adef" />
<img width="1356" height="1029" alt="Screenshot 2025-09-10 at 11 04 41 AM" src="https://github.com/user-attachments/assets/bd1bafeb-19e3-475d-a4a5-266d1cca0ce9" />
<img width="1728" height="1078" alt="Screenshot 2025-09-10 at 11 08 15 AM" src="https://github.com/user-attachments/assets/43c00bb3-1c0c-4366-92d2-1fed1f498f64" />



|  InitAuth3d | Auth3d | Sale |
|----------|----------|----------|
| 8110000000013946633  | 8110000000013946637 | 8110000000013946718  |

<!-- Similarly test txn id for manual capture 8110000000013946951 -->

## Checklist
<!-- Put an `x` in the boxes that apply -->

- [x] I formatted the code `cargo +nightly fmt --all`
- [ ] I addressed lints thrown by `cargo clippy`
- [ ] I reviewed the submitted code
- [ ] I added unit tests for my changes where possible
