feat(router): add three_ds decision rule execute api (#8148)

Co-authored-by: hyperswitch-bot[bot] <148525504+hyperswitch-bot[bot]@users.noreply.github.com>

crates/api_models/src/lib.rs

@@ -40,6 +40,7 @@ pub mod refunds;
 pub mod relay;
 pub mod routing;
 pub mod surcharge_decision_configs;
+pub mod three_ds_decision_rule;
 #[cfg(feature = "tokenization_v2")]
 pub mod tokenization;
 pub mod user;

crates/api_models/src/three_ds_decision_rule.rs

@@ -0,0 +1,93 @@
+use euclid::frontend::dir::enums::{
+    CustomerDeviceDisplaySize, CustomerDevicePlatform, CustomerDeviceType,
+};
+use utoipa::ToSchema;
+
+/// Represents the payment data used in the 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct PaymentData {
+    /// The amount of the payment in minor units (e.g., cents for USD).
+    #[schema(value_type = i64)]
+    pub amount: common_utils::types::MinorUnit,
+    /// The currency of the payment.
+    #[schema(value_type = Currency)]
+    pub currency: common_enums::Currency,
+}
+
+/// Represents metadata about the payment method used in the 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct PaymentMethodMetaData {
+    /// The card network (e.g., Visa, Mastercard) if the payment method is a card.
+    #[schema(value_type = CardNetwork)]
+    pub card_network: Option<common_enums::CardNetwork>,
+}
+
+/// Represents data about the customer's device used in the 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct CustomerDeviceData {
+    /// The platform of the customer's device (e.g., Web, Android, iOS).
+    pub platform: Option<CustomerDevicePlatform>,
+    /// The type of the customer's device (e.g., Mobile, Tablet, Desktop).
+    pub device_type: Option<CustomerDeviceType>,
+    /// The display size of the customer's device.
+    pub display_size: Option<CustomerDeviceDisplaySize>,
+}
+
+/// Represents data about the issuer used in the 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct IssuerData {
+    /// The name of the issuer.
+    pub name: Option<String>,
+    /// The country of the issuer.
+    #[schema(value_type = Country)]
+    pub country: Option<common_enums::Country>,
+}
+
+/// Represents data about the acquirer used in the 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct AcquirerData {
+    /// The country of the acquirer.
+    #[schema(value_type = Country)]
+    pub country: Option<common_enums::Country>,
+    /// The fraud rate associated with the acquirer.
+    pub fraud_rate: Option<f64>,
+}
+
+/// Represents the request to execute a 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+#[serde(deny_unknown_fields)]
+pub struct ThreeDsDecisionRuleExecuteRequest {
+    /// The ID of the routing algorithm to be executed.
+    #[schema(value_type = String)]
+    pub routing_id: common_utils::id_type::RoutingId,
+    /// Data related to the payment.
+    pub payment: PaymentData,
+    /// Optional metadata about the payment method.
+    pub payment_method: Option<PaymentMethodMetaData>,
+    /// Optional data about the customer's device.
+    pub customer_device: Option<CustomerDeviceData>,
+    /// Optional data about the issuer.
+    pub issuer: Option<IssuerData>,
+    /// Optional data about the acquirer.
+    pub acquirer: Option<AcquirerData>,
+}
+
+/// Represents the response from executing a 3DS decision rule.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, ToSchema)]
+pub struct ThreeDsDecisionRuleExecuteResponse {
+    /// The decision made by the 3DS decision rule engine.
+    #[schema(value_type = ThreeDSDecision)]
+    pub decision: common_types::three_ds_decision_rule_engine::ThreeDSDecision,
+}
+
+impl common_utils::events::ApiEventMetric for ThreeDsDecisionRuleExecuteRequest {
+    fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {
+        Some(common_utils::events::ApiEventsType::ThreeDsDecisionRule)
+    }
+}
+
+impl common_utils::events::ApiEventMetric for ThreeDsDecisionRuleExecuteResponse {
+    fn get_api_event_type(&self) -> Option<common_utils::events::ApiEventsType> {
+        Some(common_utils::events::ApiEventsType::ThreeDsDecisionRule)
+    }
+}

crates/common_enums/src/enums.rs

@@ -2596,6 +2596,7 @@ pub enum CountryAlpha3 {
     strum::EnumString,
     Deserialize,
     Serialize,
+    utoipa::ToSchema,
 )]
 pub enum Country {
     Afghanistan,

crates/common_types/src/three_ds_decision_rule_engine.rs

@@ -46,6 +46,14 @@ pub struct ThreeDSDecisionRule {
     /// The decided 3DS action based on the rules
     pub decision: ThreeDSDecision,
 }
+
+impl ThreeDSDecisionRule {
+    /// Returns the decision
+    pub fn get_decision(&self) -> ThreeDSDecision {
+        self.decision
+    }
+}
+
 impl_to_sql_from_sql_json!(ThreeDSDecisionRule);
 
 impl EuclidDirFilter for ThreeDSDecisionRule {

crates/common_utils/src/events.rs

@@ -126,6 +126,7 @@ pub enum ApiEventsType {
         token_id: Option<id_type::GlobalTokenId>,
     },
     ProcessTracker,
+    ThreeDsDecisionRule,
 }
 
 impl ApiEventMetric for serde_json::Value {}

crates/euclid/benches/backends.rs

@@ -58,6 +58,9 @@ fn get_program_data() -> (ast::Program<DummyOutput>, inputs::BackendInput) {
             mandate_type: None,
             payment_type: None,
         },
+        issuer_data: None,
+        acquirer_data: None,
+        customer_device_data: None,
     };
 
     let (_, program) = parser::program(code1).expect("Parser");

crates/euclid/src/backend.rs

@@ -16,6 +16,13 @@ pub struct BackendOutput<O> {
     pub connector_selection: O,
 }
 
+impl<O> BackendOutput<O> {
+    // get_connector_selection
+    pub fn get_output(&self) -> &O {
+        &self.connector_selection
+    }
+}
+
 pub trait EuclidBackend<O>: Sized {
     type Error: serde::Serialize;
 

crates/euclid/src/backend/inputs.rs

@@ -1,7 +1,10 @@
 use rustc_hash::FxHashMap;
 use serde::{Deserialize, Serialize};
 
-use crate::enums;
+use crate::{
+    enums,
+    frontend::dir::enums::{CustomerDeviceDisplaySize, CustomerDevicePlatform, CustomerDeviceType},
+};
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct MandateData {
@@ -30,10 +33,32 @@ pub struct PaymentInput {
     pub setup_future_usage: Option<enums::SetupFutureUsage>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct AcquirerDataInput {
+    pub country: Option<enums::Country>,
+    pub fraud_rate: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CustomerDeviceDataInput {
+    pub platform: Option<CustomerDevicePlatform>,
+    pub device_type: Option<CustomerDeviceType>,
+    pub display_size: Option<CustomerDeviceDisplaySize>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct IssuerDataInput {
+    pub name: Option<String>,
+    pub country: Option<enums::Country>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct BackendInput {
     pub metadata: Option<FxHashMap<String, String>>,
     pub payment: PaymentInput,
     pub payment_method: PaymentMethodInput,
+    pub acquirer_data: Option<AcquirerDataInput>,
+    pub customer_device_data: Option<CustomerDeviceDataInput>,
+    pub issuer_data: Option<IssuerDataInput>,
     pub mandate: MandateData,
 }

crates/euclid/src/backend/vir_interpreter.rs

@@ -153,6 +153,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -193,6 +196,9 @@ mod test {
                 mandate_type: None,
                 payment_type: Some(enums::PaymentType::SetupMandate),
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -234,6 +240,9 @@ mod test {
                 mandate_type: None,
                 payment_type: Some(enums::PaymentType::PptMandate),
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -275,6 +284,9 @@ mod test {
                 mandate_type: Some(enums::MandateType::SingleUse),
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -316,6 +328,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -357,6 +372,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -398,6 +416,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -439,6 +460,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -480,6 +504,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -523,6 +550,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
 
         let backend = VirInterpreterBackend::<DummyOutput>::with_program(program).expect("Program");
@@ -564,6 +594,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
         let mut inp_equal = inp_greater.clone();
         inp_equal.payment.amount = MinorUnit::new(123);
@@ -614,6 +647,9 @@ mod test {
                 mandate_type: None,
                 payment_type: None,
             },
+            acquirer_data: None,
+            customer_device_data: None,
+            issuer_data: None,
         };
         let mut inp_equal = inp_lower.clone();
         inp_equal.payment.amount = MinorUnit::new(123);

crates/euclid/src/backend/vir_interpreter/types.rs

@@ -54,6 +54,9 @@ impl Context {
         let payment = input.payment;
         let payment_method = input.payment_method;
         let meta_data = input.metadata;
+        let acquirer_data = input.acquirer_data;
+        let customer_device_data = input.customer_device_data;
+        let issuer_data = input.issuer_data;
         let payment_mandate = input.mandate;
 
         let mut enum_values: FxHashSet<EuclidValue> =
@@ -113,6 +116,33 @@ impl Context {
             enum_values.insert(EuclidValue::MandateAcceptanceType(mandate_acceptance_type));
         }
 
+        if let Some(acquirer_country) = acquirer_data.clone().and_then(|data| data.country) {
+            enum_values.insert(EuclidValue::AcquirerCountry(acquirer_country));
+        }
+
+        // Handle customer device data
+        if let Some(device_data) = customer_device_data {
+            if let Some(platform) = device_data.platform {
+                enum_values.insert(EuclidValue::CustomerDevicePlatform(platform));
+            }
+            if let Some(device_type) = device_data.device_type {
+                enum_values.insert(EuclidValue::CustomerDeviceType(device_type));
+            }
+            if let Some(display_size) = device_data.display_size {
+                enum_values.insert(EuclidValue::CustomerDeviceDisplaySize(display_size));
+            }
+        }
+
+        // Handle issuer data
+        if let Some(issuer) = issuer_data {
+            if let Some(name) = issuer.name {
+                enum_values.insert(EuclidValue::IssuerName(StrValue { value: name }));
+            }
+            if let Some(country) = issuer.country {
+                enum_values.insert(EuclidValue::IssuerCountry(country));
+            }
+        }
+
         let numeric_values: FxHashMap<EuclidKey, EuclidValue> = FxHashMap::from_iter([(
             EuclidKey::PaymentAmount,
             EuclidValue::PaymentAmount(types::NumValue {

crates/euclid/src/frontend/dir/enums.rs

@@ -1,4 +1,5 @@
 use strum::VariantNames;
+use utoipa::ToSchema;
 
 use crate::enums::collect_variants;
 pub use crate::enums::{
@@ -396,6 +397,7 @@ pub enum RewardType {
     strum::EnumString,
     serde::Serialize,
     serde::Deserialize,
+    ToSchema,
 )]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
@@ -417,6 +419,7 @@ pub enum CustomerDevicePlatform {
     strum::EnumString,
     serde::Serialize,
     serde::Deserialize,
+    ToSchema,
 )]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]
@@ -440,6 +443,7 @@ pub enum CustomerDeviceType {
     strum::EnumString,
     serde::Serialize,
     serde::Deserialize,
+    ToSchema,
 )]
 #[serde(rename_all = "snake_case")]
 #[strum(serialize_all = "snake_case")]

crates/euclid_wasm/src/lib.rs

@@ -222,10 +222,22 @@ pub fn get_all_connectors() -> JsResult {
 
 #[wasm_bindgen(js_name = getAllKeys)]
 pub fn get_all_keys() -> JsResult {
+    let excluded_keys = [
+        "Connector",
+        // 3DS Decision Rule Keys should not be included in the payument routing keys
+        "issuer_name",
+        "issuer_country",
+        "customer_device_platform",
+        "customer_device_type",
+        "customer_device_display_size",
+        "acquirer_country",
+        "acquirer_fraud_rate",
+    ];
+
     let keys: Vec<&'static str> = dir::DirKeyKind::VARIANTS
         .iter()
         .copied()
-        .filter(|s| s != &"Connector")
+        .filter(|s| !excluded_keys.contains(s))
         .collect();
     Ok(serde_wasm_bindgen::to_value(&keys)?)
 }
@@ -249,8 +261,8 @@ pub fn get_surcharge_keys() -> JsResult {
     Ok(serde_wasm_bindgen::to_value(keys)?)
 }
 
-#[wasm_bindgen(js_name= getThreeDsDecisionRuleEngineKeys)]
-pub fn get_three_ds_decision_rule_engine_keys() -> JsResult {
+#[wasm_bindgen(js_name= getThreeDsDecisionRuleKeys)]
+pub fn get_three_ds_decision_rule_keys() -> JsResult {
     let keys = <ThreeDSDecisionRule as EuclidDirFilter>::ALLOWED;
     Ok(serde_wasm_bindgen::to_value(keys)?)
 }

crates/openapi/Cargo.toml

@@ -15,6 +15,7 @@ api_models = { version = "0.1.0", path = "../api_models", features = ["frm", "pa
 common_utils = { version = "0.1.0", path = "../common_utils", features = ["logs"] }
 common_types = { version = "0.1.0", path = "../common_types" }
 router_env = { version = "0.1.0", path = "../router_env" }
+euclid = { version = "0.1.0", path = "../euclid" }
 
 [features]
 v2 = ["api_models/v2", "api_models/customer_v2", "common_utils/v2", "api_models/payment_methods_v2", "common_utils/payment_methods_v2", "api_models/refunds_v2", "api_models/tokenization_v2"]

crates/openapi/src/openapi.rs

@@ -202,6 +202,9 @@ Never share your secret api keys. Keep them guarded and secure.
 
         // Routes for poll apis
         routes::poll::retrieve_poll_status,
+
+        // Routes for 3DS Decision Rule
+        routes::three_ds_decision_rule::three_ds_decision_rule_execute,
     ),
     components(schemas(
         common_utils::types::MinorUnit,
@@ -236,6 +239,13 @@ Never share your secret api keys. Keep them guarded and secure.
         common_types::payments::StripeChargeResponseData,
         common_types::three_ds_decision_rule_engine::ThreeDSDecisionRule,
         common_types::three_ds_decision_rule_engine::ThreeDSDecision,
+        api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteRequest,
+        api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteResponse,
+        api_models::three_ds_decision_rule::PaymentData,
+        api_models::three_ds_decision_rule::PaymentMethodMetaData,
+        api_models::three_ds_decision_rule::CustomerDeviceData,
+        api_models::three_ds_decision_rule::IssuerData,
+        api_models::three_ds_decision_rule::AcquirerData,
         api_models::refunds::RefundRequest,
         api_models::refunds::RefundType,
         api_models::refunds::RefundResponse,
@@ -312,6 +322,7 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::enums::DisputeStage,
         api_models::enums::DisputeStatus,
         api_models::enums::CountryAlpha2,
+        api_models::enums::Country,
         api_models::enums::CountryAlpha3,
         api_models::enums::FieldType,
         api_models::enums::FrmAction,
@@ -761,6 +772,9 @@ Never share your secret api keys. Keep them guarded and secure.
         api_models::open_router::DecisionEngineGatewayWiseExtraScore,
         api_models::open_router::DecisionEngineSRSubLevelInputConfig,
         api_models::open_router::DecisionEngineEliminationData,
+        euclid::frontend::dir::enums::CustomerDevicePlatform,
+        euclid::frontend::dir::enums::CustomerDeviceType,
+        euclid::frontend::dir::enums::CustomerDeviceDisplaySize,
     )),
     modifiers(&SecurityAddon)
 )]

crates/openapi/src/routes.rs

@@ -20,5 +20,6 @@ pub mod refunds;
 pub mod relay;
 pub mod revenue_recovery;
 pub mod routing;
+pub mod three_ds_decision_rule;
 pub mod tokenization;
 pub mod webhook_events;

crates/openapi/src/routes/three_ds_decision_rule.rs

@@ -0,0 +1,14 @@
+/// 3DS Decision - Execute
+#[utoipa::path(
+    post,
+    path = "/three_ds_decision/execute",
+    request_body = ThreeDsDecisionRuleExecuteRequest,
+    responses(
+        (status = 200, description = "3DS Decision Rule Executed Successfully", body = ThreeDsDecisionRuleExecuteResponse),
+        (status = 400, description = "Bad Request")
+    ),
+    tag = "3DS Decision Rule",
+    operation_id = "Execute 3DS Decision Rule",
+    security(("api_key" = []))
+)]
+pub fn three_ds_decision_rule_execute() {}

crates/router/src/consts.rs

@@ -2,9 +2,9 @@ pub mod opensearch;
 #[cfg(feature = "olap")]
 pub mod user;
 pub mod user_role;
-
 use std::collections::HashSet;
 
+use api_models::enums::Country;
 use common_utils::consts;
 pub use hyperswitch_domain_models::consts::{
     CONNECTOR_MANDATE_REQUEST_REFERENCE_ID_LENGTH, ROUTING_ENABLED_PAYMENT_METHODS,
@@ -243,3 +243,34 @@ pub const IRRELEVANT_PAYMENT_ATTEMPT_ID: &str = "irrelevant_payment_attempt_id";
 
 // Default payment method storing TTL in redis in seconds
 pub const DEFAULT_PAYMENT_METHOD_STORE_TTL: i64 = 86400; // 1 day
+
+// List of countries that are part of the PSD2 region
+pub const PSD2_COUNTRIES: [Country; 27] = [
+    Country::Austria,
+    Country::Belgium,
+    Country::Bulgaria,
+    Country::Croatia,
+    Country::Cyprus,
+    Country::Czechia,
+    Country::Denmark,
+    Country::Estonia,
+    Country::Finland,
+    Country::France,
+    Country::Germany,
+    Country::Greece,
+    Country::Hungary,
+    Country::Ireland,
+    Country::Italy,
+    Country::Latvia,
+    Country::Lithuania,
+    Country::Luxembourg,
+    Country::Malta,
+    Country::Netherlands,
+    Country::Poland,
+    Country::Portugal,
+    Country::Romania,
+    Country::Slovakia,
+    Country::Slovenia,
+    Country::Spain,
+    Country::Sweden,
+];

crates/router/src/core.rs

@@ -49,6 +49,7 @@ pub mod refunds_v2;
 pub mod debit_routing;
 pub mod routing;
 pub mod surcharge_decision_config;
+pub mod three_ds_decision_rule;
 #[cfg(feature = "olap")]
 pub mod user;
 #[cfg(feature = "olap")]

crates/router/src/core/payments/routing.rs

@@ -196,6 +196,9 @@ pub fn make_dsl_input_for_payouts(
         metadata,
         payment,
         payment_method,
+        acquirer_data: None,
+        customer_device_data: None,
+        issuer_data: None,
     })
 }
 
@@ -308,6 +311,9 @@ pub fn make_dsl_input(
         payment: payment_input,
         payment_method: payment_method_input,
         mandate: mandate_data,
+        acquirer_data: None,
+        customer_device_data: None,
+        issuer_data: None,
     })
 }
 
@@ -419,6 +425,9 @@ pub fn make_dsl_input(
         payment: payment_input,
         payment_method: payment_method_input,
         mandate: mandate_data,
+        acquirer_data: None,
+        customer_device_data: None,
+        issuer_data: None,
     })
 }
 
@@ -1083,6 +1092,9 @@ pub async fn perform_session_flow_routing<'a>(
             mandate_type: None,
             payment_type: None,
         },
+        acquirer_data: None,
+        customer_device_data: None,
+        issuer_data: None,
     };
 
     for connector_data in session_input.chosen.iter() {
@@ -1227,6 +1239,9 @@ pub async fn perform_session_flow_routing(
             mandate_type: None,
             payment_type: None,
         },
+        acquirer_data: None,
+        customer_device_data: None,
+        issuer_data: None,
     };
 
     for connector_data in session_input.chosen.iter() {
@@ -1529,6 +1544,9 @@ pub fn make_dsl_input_for_surcharge(
         payment: payment_input,
         payment_method: payment_method_input,
         mandate: mandate_data,
+        acquirer_data: None,
+        customer_device_data: None,
+        issuer_data: None,
     };
     Ok(backend_input)
 }

crates/router/src/core/three_ds_decision_rule.rs

@@ -0,0 +1,72 @@
+pub mod utils;
+
+use common_types::three_ds_decision_rule_engine::ThreeDSDecisionRule;
+use common_utils::ext_traits::ValueExt;
+use error_stack::ResultExt;
+use euclid::{
+    backend::{self, inputs as dsl_inputs, EuclidBackend},
+    frontend::ast,
+};
+use hyperswitch_domain_models::merchant_context::MerchantContext;
+use router_env::{instrument, tracing};
+
+use crate::{
+    core::{
+        errors,
+        errors::{RouterResponse, StorageErrorExt},
+    },
+    services,
+    types::transformers::ForeignFrom,
+    SessionState,
+};
+
+#[instrument(skip_all)]
+pub async fn execute_three_ds_decision_rule(
+    state: SessionState,
+    merchant_context: MerchantContext,
+    request: api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteRequest,
+) -> RouterResponse<api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteResponse> {
+    let db = state.store.as_ref();
+    // Retrieve the rule from database
+    let routing_algorithm = db
+        .find_routing_algorithm_by_algorithm_id_merchant_id(
+            &request.routing_id,
+            merchant_context.get_merchant_account().get_id(),
+        )
+        .await
+        .to_not_found_response(errors::ApiErrorResponse::ResourceIdNotFound)?;
+    let algorithm: Algorithm = routing_algorithm
+        .algorithm_data
+        .parse_value("Algorithm")
+        .change_context(errors::ApiErrorResponse::InternalServerError)
+        .attach_printable("Error parsing program from three_ds_decision rule algorithm")?;
+    let program: ast::Program<ThreeDSDecisionRule> = algorithm
+        .data
+        .parse_value("Program<ThreeDSDecisionRule>")
+        .change_context(errors::ApiErrorResponse::InternalServerError)
+        .attach_printable("Error parsing program from three_ds_decision rule algorithm")?;
+    // Construct backend input from request
+    let backend_input = dsl_inputs::BackendInput::foreign_from(request.clone());
+    // Initialize interpreter with the rule program
+    let interpreter = backend::VirInterpreterBackend::with_program(program)
+        .change_context(errors::ApiErrorResponse::InternalServerError)
+        .attach_printable("Error initializing DSL interpreter backend")?;
+    // Execute the rule
+    let result = interpreter
+        .execute(backend_input)
+        .change_context(errors::ApiErrorResponse::InternalServerError)
+        .attach_printable("Error executing 3DS decision rule")?;
+    // Apply PSD2 validations to the decision
+    let final_decision =
+        utils::apply_psd2_validations_during_execute(result.get_output().get_decision(), &request);
+    // Construct response
+    let response = api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteResponse {
+        decision: final_decision,
+    };
+    Ok(services::ApplicationResponse::Json(response))
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct Algorithm {
+    data: serde_json::Value,
+}

crates/router/src/core/three_ds_decision_rule/utils.rs

@@ -0,0 +1,115 @@
+use api_models::three_ds_decision_rule as api_threedsecure;
+use common_types::three_ds_decision_rule_engine::ThreeDSDecision;
+use euclid::backend::inputs as dsl_inputs;
+
+use crate::{consts::PSD2_COUNTRIES, types::transformers::ForeignFrom};
+
+// function to apply PSD2 validations to the decision
+pub fn apply_psd2_validations_during_execute(
+    decision: ThreeDSDecision,
+    request: &api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteRequest,
+) -> ThreeDSDecision {
+    let issuer_in_psd2 = request
+        .issuer
+        .as_ref()
+        .and_then(|issuer| issuer.country)
+        .map(|country| PSD2_COUNTRIES.contains(&country))
+        .unwrap_or(false);
+    let acquirer_in_psd2 = request
+        .acquirer
+        .as_ref()
+        .and_then(|acquirer| acquirer.country)
+        .map(|country| PSD2_COUNTRIES.contains(&country))
+        .unwrap_or(false);
+    if issuer_in_psd2 && acquirer_in_psd2 {
+        // If both issuer and acquirer are in PSD2 region
+        match decision {
+            // If the decision is to enforce no 3DS, override it to enforce 3DS
+            ThreeDSDecision::NoThreeDs => ThreeDSDecision::ChallengeRequested,
+            _ => decision,
+        }
+    } else {
+        // If PSD2 doesn't apply, exemptions cannot be applied
+        match decision {
+            ThreeDSDecision::NoThreeDs => ThreeDSDecision::NoThreeDs,
+            // For all other decisions (including exemptions), enforce challenge as exemptions are only valid in PSD2 regions
+            _ => ThreeDSDecision::ChallengeRequested,
+        }
+    }
+}
+
+impl ForeignFrom<api_threedsecure::PaymentData> for dsl_inputs::PaymentInput {
+    fn foreign_from(request_payment_data: api_threedsecure::PaymentData) -> Self {
+        Self {
+            amount: request_payment_data.amount,
+            currency: request_payment_data.currency,
+            authentication_type: None,
+            capture_method: None,
+            business_country: None,
+            billing_country: None,
+            business_label: None,
+            setup_future_usage: None,
+            card_bin: None,
+        }
+    }
+}
+
+impl ForeignFrom<Option<api_threedsecure::PaymentMethodMetaData>>
+    for dsl_inputs::PaymentMethodInput
+{
+    fn foreign_from(
+        request_payment_method_metadata: Option<api_threedsecure::PaymentMethodMetaData>,
+    ) -> Self {
+        Self {
+            payment_method: None,
+            payment_method_type: None,
+            card_network: request_payment_method_metadata.and_then(|pm| pm.card_network),
+        }
+    }
+}
+
+impl ForeignFrom<api_threedsecure::CustomerDeviceData> for dsl_inputs::CustomerDeviceDataInput {
+    fn foreign_from(request_customer_device_data: api_threedsecure::CustomerDeviceData) -> Self {
+        Self {
+            platform: request_customer_device_data.platform,
+            device_type: request_customer_device_data.device_type,
+            display_size: request_customer_device_data.display_size,
+        }
+    }
+}
+
+impl ForeignFrom<api_threedsecure::IssuerData> for dsl_inputs::IssuerDataInput {
+    fn foreign_from(request_issuer_data: api_threedsecure::IssuerData) -> Self {
+        Self {
+            name: request_issuer_data.name,
+            country: request_issuer_data.country,
+        }
+    }
+}
+
+impl ForeignFrom<api_threedsecure::AcquirerData> for dsl_inputs::AcquirerDataInput {
+    fn foreign_from(request_acquirer_data: api_threedsecure::AcquirerData) -> Self {
+        Self {
+            country: request_acquirer_data.country,
+            fraud_rate: request_acquirer_data.fraud_rate,
+        }
+    }
+}
+
+impl ForeignFrom<api_threedsecure::ThreeDsDecisionRuleExecuteRequest> for dsl_inputs::BackendInput {
+    fn foreign_from(request: api_threedsecure::ThreeDsDecisionRuleExecuteRequest) -> Self {
+        Self {
+            metadata: None,
+            payment: dsl_inputs::PaymentInput::foreign_from(request.payment),
+            payment_method: dsl_inputs::PaymentMethodInput::foreign_from(request.payment_method),
+            mandate: dsl_inputs::MandateData {
+                mandate_acceptance_type: None,
+                mandate_type: None,
+                payment_type: None,
+            },
+            acquirer_data: request.acquirer.map(ForeignFrom::foreign_from),
+            customer_device_data: request.customer_device.map(ForeignFrom::foreign_from),
+            issuer_data: request.issuer.map(ForeignFrom::foreign_from),
+        }
+    }
+}

crates/router/src/lib.rs

@@ -145,7 +145,8 @@ pub fn mk_app(
             .service(routes::RelayWebhooks::server(state.clone()))
             .service(routes::Webhooks::server(state.clone()))
             .service(routes::Hypersense::server(state.clone()))
-            .service(routes::Relay::server(state.clone()));
+            .service(routes::Relay::server(state.clone()))
+            .service(routes::ThreeDsDecisionRule::server(state.clone()));
 
         #[cfg(feature = "oltp")]
         {

crates/router/src/routes.rs

@@ -47,6 +47,7 @@ pub mod recon;
 pub mod refunds;
 #[cfg(feature = "olap")]
 pub mod routing;
+pub mod three_ds_decision_rule;
 pub mod tokenization;
 #[cfg(feature = "olap")]
 pub mod user;
@@ -85,8 +86,8 @@ pub use self::app::{
     ApiKeys, AppState, ApplePayCertificatesMigration, Cache, Cards, Configs, ConnectorOnboarding,
     Customers, Disputes, EphemeralKey, FeatureMatrix, Files, Forex, Gsm, Health, Hypersense,
     Mandates, MerchantAccount, MerchantConnectorAccount, PaymentLink, PaymentMethods, Payments,
-    Poll, ProcessTracker, Profile, ProfileNew, Refunds, Relay, RelayWebhooks, SessionState, User,
-    Webhooks,
+    Poll, ProcessTracker, Profile, ProfileNew, Refunds, Relay, RelayWebhooks, SessionState,
+    ThreeDsDecisionRule, User, Webhooks,
 };
 #[cfg(feature = "olap")]
 pub use self::app::{Blocklist, Organization, Routing, Verify, WebhookEvents};

crates/router/src/routes/app.rs

@@ -99,7 +99,7 @@ pub use crate::{
 use crate::{
     configs::{secrets_transformers, Settings},
     db::kafka_store::{KafkaStore, TenantID},
-    routes::hypersense as hypersense_routes,
+    routes::{hypersense as hypersense_routes, three_ds_decision_rule},
 };
 
 #[derive(Clone)]
@@ -2183,6 +2183,20 @@ impl Gsm {
     }
 }
 
+pub struct ThreeDsDecisionRule;
+
+#[cfg(feature = "oltp")]
+impl ThreeDsDecisionRule {
+    pub fn server(state: AppState) -> Scope {
+        web::scope("/three_ds_decision")
+            .app_data(web::Data::new(state))
+            .service(
+                web::resource("/execute")
+                    .route(web::post().to(three_ds_decision_rule::execute_decision_rule)),
+            )
+    }
+}
+
 #[cfg(feature = "olap")]
 pub struct Verify;
 

crates/router/src/routes/lock_utils.rs

@@ -44,6 +44,7 @@ pub enum ApiIdentifier {
     PaymentMethodSession,
     ProcessTracker,
     Proxy,
+    ThreeDsDecisionRule,
     GenericTokenization,
 }
 
@@ -344,6 +345,7 @@ impl From<Flow> for ApiIdentifier {
             Flow::RevenueRecoveryRetrieve => Self::ProcessTracker,
             Flow::Proxy => Self::Proxy,
 
+            Flow::ThreeDsDecisionRuleExecute => Self::ThreeDsDecisionRule,
             Flow::TokenizationCreate | Flow::TokenizationRetrieve => Self::GenericTokenization,
         }
     }

crates/router/src/routes/three_ds_decision_rule.rs

@@ -0,0 +1,43 @@
+use actix_web::{web, Responder};
+use hyperswitch_domain_models::merchant_context::{Context, MerchantContext};
+use router_env::{instrument, tracing, Flow};
+
+use crate::{
+    self as app,
+    core::{api_locking, three_ds_decision_rule as three_ds_decision_rule_core},
+    services::{api, authentication as auth},
+};
+
+#[instrument(skip_all, fields(flow = ?Flow::ThreeDsDecisionRuleExecute))]
+#[cfg(feature = "oltp")]
+pub async fn execute_decision_rule(
+    state: web::Data<app::AppState>,
+    req: actix_web::HttpRequest,
+    payload: web::Json<api_models::three_ds_decision_rule::ThreeDsDecisionRuleExecuteRequest>,
+) -> impl Responder {
+    let flow = Flow::ThreeDsDecisionRuleExecute;
+    let payload = payload.into_inner();
+    Box::pin(api::server_wrap(
+        flow,
+        state,
+        &req,
+        payload,
+        |state, auth: auth::AuthenticationData, req, _| {
+            let merchant_context = MerchantContext::NormalMerchant(Box::new(Context(
+                auth.merchant_account,
+                auth.key_store,
+            )));
+            three_ds_decision_rule_core::execute_three_ds_decision_rule(
+                state,
+                merchant_context,
+                req,
+            )
+        },
+        &auth::HeaderAuth(auth::ApiKeyAuth {
+            is_connected_allowed: false,
+            is_platform_allowed: false,
+        }),
+        api_locking::LockAction::NotApplicable,
+    ))
+    .await
+}

crates/router_env/src/logger/types.rs

@@ -594,6 +594,8 @@ pub enum Flow {
     CloneConnector,
     ///Proxy Flow
     Proxy,
+    /// ThreeDs Decision Rule Execute flow
+    ThreeDsDecisionRuleExecute,
 }
 
 /// Trait for providing generic behaviour to flow metric