From 73716fc8b5a9541fed9aeb3b8b292803bd3c4dfc Mon Sep 17 00:00:00 2001
From: ChiragKV-Juspay <chirag.kv@juspay.in>
Date: Mon, 15 Sep 2025 14:37:41 +0530
Subject: [PATCH] added trident integration and made changes to the api lib

---
 app/build.gradle.kts                          |   6 +-
 .../io/hyperswitch/demo_app/MainActivity.kt   | 592 +++++++++++++-----
 app/src/main/res/layout/activity_main.xml     |  55 ++
 .../hyperswitch/modular_3ds/ThreeDSManager.kt |  81 ++-
 .../api/AuthenticationConfiguration.kt        |  13 +
 .../api/AuthenticationRequestParameters.kt    |  13 +
 .../modular_3ds/api/AuthenticationResult.kt   |  10 +
 .../modular_3ds/api/ChallengeEvents.kt        |  40 ++
 .../api/ThreeDSAuthenticationSession.kt       |  87 +++
 .../modular_3ds/api/ThreeDSSession.kt         |  55 ++
 .../modular_3ds/api/ThreeDSTransaction.kt     |  82 +++
 .../callbacks/AuthParametersCallback.kt       |  24 +
 .../callbacks/ChallengeCallback.kt            |  12 +-
 .../callbacks/TransactionCallback.kt          |  24 +
 .../modular_3ds/models/ChallengeParameters.kt |   6 +-
 .../models/ThreeDSConfiguration.kt            |   3 -
 .../modular_3ds/models/TransactionRequest.kt  |  49 ++
 .../modular_3ds/provider/ThreeDSProvider.kt   |  26 +-
 .../modular_3ds/mock/MockThreeDSProvider.kt   |  17 +-
 .../netcetera/NetceteraThreeDSProvider.kt     | 125 +++-
 .../trident/TridentConfigurator.kt            |  28 +
 .../trident/TridentThreeDSProvider.kt         | 464 ++++++++++----
 22 files changed, 1499 insertions(+), 313 deletions(-)
 create mode 100644 app/src/main/res/layout/activity_main.xml
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationConfiguration.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationRequestParameters.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationResult.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ChallengeEvents.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSAuthenticationSession.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSSession.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSTransaction.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/AuthParametersCallback.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/TransactionCallback.kt
 create mode 100644 modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/TransactionRequest.kt
 create mode 100644 modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentConfigurator.kt

diff --git a/app/build.gradle.kts b/app/build.gradle.kts
index 85ffa99..4865e71 100644
--- a/app/build.gradle.kts
+++ b/app/build.gradle.kts
@@ -41,8 +41,12 @@ dependencies {
     // modular 3DS library
     implementation(project(":modular-3ds-api"))
     // implementation(project(":modular-3ds-mock"))
-    implementation(project(":modular-3ds-netcetera"))
+    implementation(project(":modular-3ds-trident"))
     
     // UI dependencies for demo
     implementation(libs.androidx.appcompat)
+    
+    // HTTP client for API calls
+    implementation("com.squareup.okhttp3:okhttp:4.12.0")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-android:1.7.3")
 }
diff --git a/app/src/main/java/io/hyperswitch/demo_app/MainActivity.kt b/app/src/main/java/io/hyperswitch/demo_app/MainActivity.kt
index b51bd71..a03cbac 100644
--- a/app/src/main/java/io/hyperswitch/demo_app/MainActivity.kt
+++ b/app/src/main/java/io/hyperswitch/demo_app/MainActivity.kt
@@ -1,198 +1,488 @@
 package io.hyperswitch.demo_app
 
+import android.app.Activity
 import android.os.Bundle
 import android.util.Log
-import android.view.Gravity
-import android.view.ViewGroup
 import android.widget.Button
-import android.widget.LinearLayout
 import android.widget.TextView
-import android.widget.Toast
-import androidx.appcompat.app.AppCompatActivity
-import io.hyperswitch.modular_3ds.ThreeDSManager
-import io.hyperswitch.modular_3ds.callbacks.AuthenticationCallback
-import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
-import io.hyperswitch.modular_3ds.models.*
-import io.hyperswitch.modular_3ds.netcetera.NetceteraProviderFactory
+import io.hyperswitch.modular_3ds.models.ThreeDSEnvironment
+import io.hyperswitch.modular_3ds.models.UiCustomization
 import io.hyperswitch.modular_3ds.provider.ProviderRegistry
+import io.hyperswitch.modular_3ds.trident.TridentProviderFactory
+import io.hyperswitch.modular_3ds.api.*
+import io.hyperswitch.modular_3ds.models.ChallengeParameters
+import okhttp3.*
+import okhttp3.MediaType.Companion.toMediaType
+import okhttp3.RequestBody.Companion.toRequestBody
+import org.json.JSONObject
+import java.io.IOException
+
+class MainActivity : Activity() {
 
-class MainActivity : AppCompatActivity() {
-    
     private lateinit var statusText: TextView
-    private lateinit var initButton: Button
-    private lateinit var authButton: Button
-    private lateinit var providersButton: Button
+    private var publishKey: String = ""
+    private var paymentIntentClientSecret: String = ""
+    
+    // New merchant-facing API objects
+    private lateinit var authenticationSession: ThreeDSAuthenticationSession
+    private var session: ThreeDSSession? = null
+    private var transaction: ThreeDSTransaction? = null
+    private var aReqParams: AuthenticationRequestParameters? = null
+    private var challengeParameters: ChallengeParameters? = null
+    
+    // API credentials and data
+    private val apiKey = ""
+    private val profileId = ""
+    private val baseUrl = "https://sandbox.hyperswitch.io"
+    private var authenticationId: String? = null
     
-    private val threeDSManager = ThreeDSManager.getInstance()
+    // Eligibility response data
+    private var threeDsServerTransactionId: String? = null
+    private var messageVersion: String? = null
+    private var directoryServerId: String? = null
     
+    // HTTP client - use singleton to avoid creating multiple instances
+    private val httpClient by lazy {
+        OkHttpClient.Builder()
+            .connectTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+            .readTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+            .writeTimeout(15, java.util.concurrent.TimeUnit.SECONDS)
+            .build()
+    }
+
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
-        
-        // Register mock provider for testing
-        ProviderRegistry.registerProvider(NetceteraProviderFactory())
-        
-        setupUI()
+        setContentView(R.layout.activity_main)
+
+        statusText = findViewById(R.id.statusText)
+
+        // Register providers for testing
+        ProviderRegistry.registerProvider(TridentProviderFactory())
+
+        // Initialize ThreeDSAuthenticationSession using the new unified 3DS library
+        authenticationSession = ThreeDSAuthenticationSession(this, publishKey)
+
+        setupButtons()
     }
-    
-    private fun setupUI() {
-        val layout = LinearLayout(this).apply {
-            layoutParams = ViewGroup.LayoutParams(
-                ViewGroup.LayoutParams.MATCH_PARENT,
-                ViewGroup.LayoutParams.MATCH_PARENT
-            )
-            orientation = LinearLayout.VERTICAL
-            gravity = Gravity.CENTER
-            setPadding(32, 32, 32, 32)
-        }
-        
-        val titleText = TextView(this).apply {
-            text = "Modular 3DS Demo"
-            textSize = 24f
-            gravity = Gravity.CENTER
+
+    override fun onDestroy() {
+        super.onDestroy()
+        // Clean up resources to prevent memory leaks
+        session = null
+        transaction = null
+        aReqParams = null
+        challengeParameters = null
+
+        Log.d("ThreeDSTest", "Cleared activity references")
+
+        // Cancel any pending HTTP calls
+        try {
+            httpClient.dispatcher.executorService.shutdown()
+        } catch (e: Exception) {
+            Log.w("ThreeDSTest", "Error shutting down HTTP client: ${e.message}")
         }
-        
-        statusText = TextView(this).apply {
-            text = "Ready to test 3DS authentication"
-            textSize = 16f
-            gravity = Gravity.CENTER
-            setPadding(0, 32, 0, 32)
+    }
+
+    private fun setupButtons() {
+        findViewById<Button>(R.id.btnInit3DS).setOnClickListener {
+            setStatus("Step 1: Initializing Authentication Session...")
+            initializeAndCreateAuthentication()
         }
-        
-        providersButton = Button(this).apply {
-            text = "Check Available Providers"
-            setOnClickListener { checkProviders() }
+
+        findViewById<Button>(R.id.btnGenerateAReq).setOnClickListener {
+            setStatus("Step 2: Creating Transaction and Generating AReq...")
+            createTransactionAndGenerateAReq()
         }
-        
-        initButton = Button(this).apply {
-            text = "Initialize 3DS"
-            setOnClickListener { initialize3DS() }
+
+        findViewById<Button>(R.id.btnReceiveChallenge).setOnClickListener {
+            setStatus("Step 3: Making Authentication API Call...")
+            makeAuthenticationApiCall()
         }
-        
-        authButton = Button(this).apply {
-            text = "Test Authentication"
-            isEnabled = false
-            setOnClickListener { testAuthentication() }
+
+        findViewById<Button>(R.id.btnDoChallenge).setOnClickListener {
+            setStatus("Step 4: Performing Challenge...")
+            performChallenge()
         }
-        
-        layout.addView(titleText)
-        layout.addView(statusText)
-        layout.addView(providersButton)
-        layout.addView(initButton)
-        layout.addView(authButton)
-        
-        setContentView(layout)
     }
-    
-    private fun checkProviders() {
-        val providers = ThreeDSManager.getAvailableProviders()
-        val providerInfo = ThreeDSManager.getProviderInfo()
-        
-        val message = if (providers.isEmpty()) {
-            "No providers available"
-        } else {
-            "Available providers:\n" + providerInfo.joinToString("\n") { 
-                "${it.name} v${it.version} (priority: ${it.priority})"
+
+    private fun initializeAndCreateAuthentication() {
+        try {
+            setStatus("🔧 Initializing 3DS SDK...")
+
+            // Create authentication configuration with merchant-provided 3DS SDK settings
+            val authenticationConfiguration = AuthenticationConfiguration(
+                apiKey = apiKey,
+                environment = ThreeDSEnvironment.SANDBOX,
+                uiCustomization = null
+            )
+
+            session = authenticationSession.initThreeDsSession(
+                authIntentClientSecret = paymentIntentClientSecret,
+                configuration = authenticationConfiguration
+            ) { result ->
+                when (result) {
+                    is AuthenticationResult.Success -> {
+                        setStatus("✅ 3DS SDK initialized. Making API call to create authentication...")
+                        createAuthenticationApiCall()
+                    }
+                    is AuthenticationResult.Error -> {
+                        setStatus("❌ Error: ${result.message}")
+                    }
+                    is AuthenticationResult.Challenge -> {
+                        setStatus("🔄 Challenge required")
+                    }
+                }
             }
+
+        } catch (e: Exception) {
+            setStatus("❌ Error initializing session: ${e.message}")
+            Log.e("ThreeDSTest", "Error in initializeAndCreateAuthentication", e)
         }
-        
-        statusText.text = message
-        Log.d("3DS_DEMO", message)
     }
-    
-    private fun initialize3DS() {
-        statusText.text = "Initializing 3DS..."
-        
-        val configuration = ThreeDSConfiguration.Builder()
-            .setEnvironment(ThreeDSEnvironment.SANDBOX)
-            .setDirectoryServerId("test-ds-id")
-            .setTimeout(30000)
-            .setEnableLogging(true)
+
+    private fun createAuthenticationApiCall() {
+        val requestBody = JSONObject().apply {
+            put("amount", 1050)
+            put("currency", "EUR")
+            put("acquirer_details", JSONObject().apply {
+                put("acquirer_merchant_id", "12134")
+                put("acquirer_bin", "438309")
+                put("merchant_country_code", "004")
+            })
+            put("authentication_connector", "juspaythreedsserver")
+        }
+
+        val request = Request.Builder()
+            .url("$baseUrl/authentication")
+            .post(requestBody.toString().toRequestBody("application/json".toMediaType()))
+            .addHeader("X-Profile-Id", profileId)
+            .addHeader("Content-Type", "application/json")
+            .addHeader("api-key", apiKey)
             .build()
-        
-        threeDSManager.initialize(this, configuration, object : InitializationCallback {
-            override fun onInitializationSuccess() {
+
+        httpClient.newCall(request).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
                 runOnUiThread {
-                    statusText.text = "3DS initialized successfully with provider: ${threeDSManager.getCurrentProvider()}"
-                    authButton.isEnabled = true
-                    Toast.makeText(this@MainActivity, "3DS Ready!", Toast.LENGTH_SHORT).show()
+                    setStatus("❌ API Error: ${e.message}")
                 }
-                Log.d("3DS_DEMO", "Initialization successful")
             }
-            
-            override fun onInitializationFailure(error: ThreeDSError) {
+
+            override fun onResponse(call: Call, response: Response) {
+                val responseBody = response.body?.string()
+                response.close()
+
                 runOnUiThread {
-                    statusText.text = "Initialization failed: ${error.message}"
-                    authButton.isEnabled = false
-                    Toast.makeText(this@MainActivity, "Init failed: ${error.message}", Toast.LENGTH_LONG).show()
+                    if (response.isSuccessful) {
+                        Log.d("ThreeDSTest", "Auth Create Response: $responseBody")
+                        try {
+                            val jsonResponse = JSONObject(responseBody ?: "")
+                            authenticationId = jsonResponse.getString("authentication_id")
+                            setStatus("✅ Authentication created successfully. ID: $authenticationId")
+                            // Now call eligibility API
+                            callEligibilityApiCall()
+                        } catch (e: Exception) {
+                            setStatus("❌ Error parsing response: ${e.message}")
+                        }
+                    } else {
+                        setStatus("❌ API Error: ${response.code} - ${response.message}")
+                    }
                 }
-                Log.e("3DS_DEMO", "Initialization failed: ${error.message}", )
             }
         })
     }
-    
-    private fun testAuthentication() {
-        statusText.text = "Testing authentication..."
-        
-        val request = AuthenticationRequest(
-            transactionId = "test-txn-${System.currentTimeMillis()}",
-            amount = "100.00",
-            currency = "USD",
-            cardNumber = "4000000000000000", // Test card for frictionless flow
-            expiryMonth = "12",
-            expiryYear = "25",
-            merchantName = "Test Merchant",
-            merchantCategoryCode = "5411",
-            acquirerBin = "123456",
-            acquirerMerchantId = "test-merchant-123",
-            deviceData = null,
-            billingAddress = null,
-            shippingAddress = null,
-            email = "test@example.com",
-            phoneNumber = "+1234567890"
-        )
-        
-        threeDSManager.authenticate(request, object : AuthenticationCallback {
-            override fun onAuthenticationSuccess(response: AuthenticationResponse) {
+
+    private fun callEligibilityApiCall() {
+        if (authenticationId == null) {
+            setStatus("❌ Error: Authentication ID is required for eligibility call")
+            return
+        }
+
+        setStatus("🔄 Making eligibility API call...")
+
+        // Create request body for eligibility check with proper structure
+        val requestBody = JSONObject().apply {
+            put("payment_method", "card")
+            put("payment_method_data", JSONObject().apply {
+                put("card", JSONObject().apply {
+                    put("card_number", "5306889942833340")
+                    put("card_exp_month", "10")
+                    put("card_exp_year", "24")
+                    put("card_holder_name", "joseph Doe")
+                    put("card_cvc", "123")
+                })
+            })
+            put("billing", JSONObject().apply {
+                put("address", JSONObject().apply {
+                    put("line1", "1467")
+                    put("line2", "Harrison Street")
+                    put("line3", "Harrison Street")
+                    put("city", "San Fransico")
+                    put("state", "CA")
+                    put("zip", "94122")
+                    put("country", "US")
+                    put("first_name", "PiX")
+                })
+                put("phone", JSONObject().apply {
+                    put("number", "123456789")
+                    put("country_code", "12")
+                })
+            })
+            put("shipping", JSONObject().apply {
+                put("address", JSONObject().apply {
+                    put("line1", "1467")
+                    put("line2", "Harrison Street")
+                    put("line3", "Harrison Street")
+                    put("city", "San Fransico")
+                    put("state", "California")
+                    put("zip", "94122")
+                    put("country", "US")
+                    put("first_name", "PiX")
+                })
+                put("phone", JSONObject().apply {
+                    put("number", "123456789")
+                    put("country_code", "12")
+                })
+            })
+            put("email", "sahkasssslplanet@gmail.com")
+            put("browser_information", JSONObject().apply {
+                put("user_agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/70.0.3538.110 Safari/537.36")
+                put("accept_header", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8")
+                put("language", "nl-NL")
+                put("color_depth", 24)
+                put("screen_height", 723)
+                put("screen_width", 1536)
+                put("time_zone", 0)
+                put("java_enabled", true)
+                put("java_script_enabled", true)
+                put("ip_address", "115.99.183.2")
+            })
+        }
+
+        val request = Request.Builder()
+            .url("$baseUrl/authentication/$authenticationId/eligibility")
+            .post(requestBody.toString().toRequestBody("application/json".toMediaType()))
+            .addHeader("Content-Type", "application/json")
+            .addHeader("api-key", apiKey)
+            .build()
+
+        httpClient.newCall(request).enqueue(object : Callback {
+            override fun onFailure(call: Call, e: IOException) {
                 runOnUiThread {
-                    val message = "Authentication successful!\n" +
-                            "Status: ${response.status}\n" +
-                            "ECI: ${response.eci}\n" +
-                            "Liability Shift: ${response.liabilityShift}\n" +
-                            "Challenge Required: ${response.challengeRequired}"
-                    statusText.text = message
-                    Toast.makeText(this@MainActivity, "Auth Success!", Toast.LENGTH_SHORT).show()
+                    setStatus("❌ Eligibility API Error: ${e.message}")
                 }
-                Log.d("3DS_DEMO", "Authentication successful: ${response.status}")
             }
-            
-            override fun onAuthenticationFailure(error: ThreeDSError) {
+
+            override fun onResponse(call: Call, response: Response) {
+                val responseBody = response.body?.string()
+                response.close()
+
                 runOnUiThread {
-                    statusText.text = "Authentication failed: ${error.message}"
-                    Toast.makeText(this@MainActivity, "Auth failed: ${error.message}", Toast.LENGTH_LONG).show()
+                    if (response.isSuccessful) {
+                        Log.d("ThreeDSTest", "Eligibility Response: $responseBody")
+                        try {
+                            val jsonResponse = JSONObject(responseBody ?: "")
+
+                            // Extract eligibility response data
+                            val eligibilityParams = jsonResponse.optJSONObject("eligibility_response_params")
+                            val threeDsData = eligibilityParams?.optJSONObject("ThreeDsData")
+
+                            if (threeDsData != null) {
+                                threeDsServerTransactionId = threeDsData.optString("three_ds_server_transaction_id")
+                                messageVersion = threeDsData.optString("message_version")
+                                directoryServerId = threeDsData.optString("directory_server_id")
+
+                                setStatus("✅ Eligibility completed - ready for transaction creation")
+                            } else {
+                                setStatus("✅ Eligibility completed - no 3DS data found")
+                            }
+                        } catch (e: Exception) {
+                            setStatus("❌ Error parsing eligibility response: ${e.message}")
+                        }
+                    } else {
+                        setStatus("❌ Eligibility API Error: ${response.code} - ${response.message}")
+                    }
                 }
-                Log.e("3DS_DEMO", "Authentication failed: ${error.message}")
             }
-            
-            override fun onChallengeRequired() {
+        })
+    }
+
+    private fun createTransactionAndGenerateAReq() {
+        try {
+            if (session == null) {
+                setStatus("❌ Error: Please initialize authentication session first")
+                return
+            }
+
+            if (authenticationId == null) {
+                setStatus("❌ Error: Please create authentication first")
+                return
+            }
+
+            // Create transaction with values from eligibility response
+            transaction = session!!.createTransaction(directoryServerId, messageVersion ?: "2.1.0", "MASTERCARD")
+
+            setStatus("🔄 Generating AReq parameters...")
+
+            transaction!!.getAuthenticationRequestParameters { result ->
                 runOnUiThread {
-                    statusText.text = "Challenge required - presenting challenge UI..."
-                    Toast.makeText(this@MainActivity, "Challenge required", Toast.LENGTH_SHORT).show()
+                    if (result != null) {
+                        aReqParams = result
+                        setStatus("✅ AReq generated - SDK Transaction ID: ${result.sdkTransactionID}")
+                    } else {
+                        setStatus("❌ Failed to generate AReq parameters")
+                    }
                 }
-                Log.d("3DS_DEMO", "Challenge required")
             }
-            
-            override fun onAuthenticationCancelled() {
+
+        } catch (e: Exception) {
+            setStatus("❌ Error creating transaction: ${e.message}")
+            Log.e("ThreeDSTest", "Error in createTransactionAndGenerateAReq", e)
+        }
+    }
+
+    private fun makeAuthenticationApiCall() {
+        try {
+            if (authenticationId == null || aReqParams == null) {
+                setStatus("❌ Error: Please complete previous steps first")
+                return
+            }
+
+            setStatus("🔄 Making authentication API call...")
+
+            val requestBody = JSONObject().apply {
+                put("device_channel", "APP")
+                put("threeds_method_comp_ind", "N")
+                put("sdk_information", JSONObject().apply {
+                    put("sdk_app_id", aReqParams!!.sdkAppID)
+                    put("sdk_enc_data", aReqParams!!.deviceData) // Map deviceData to sdk_enc_data
+                    put("sdk_trans_id", aReqParams!!.sdkTransactionID)
+                    put("sdk_reference_number", aReqParams!!.sdkReferenceNumber)
+                    put("sdk_max_timeout", aReqParams!!.sdkMaxTimeout)
+
+                    // Parse and add sdk_ephem_pub_key if available
+                    aReqParams!!.sdkEphemeralPublicKey?.let { ephemeralKey ->
+                        try {
+                            val ephemeralKeyJson = JSONObject(ephemeralKey)
+                            put("sdk_ephem_pub_key", ephemeralKeyJson)
+                        } catch (e: Exception) {
+                            Log.w("ThreeDSTest", "Failed to parse sdkEphemeralPublicKey: ${e.message}")
+                        }
+                    }
+                })
+            }
+
+            val request = Request.Builder()
+                .url("$baseUrl/authentication/$authenticationId/authenticate")
+                .post(requestBody.toString().toRequestBody("application/json".toMediaType()))
+                .addHeader("Content-Type", "application/json")
+                .addHeader("api-key", apiKey)
+                .build()
+
+            httpClient.newCall(request).enqueue(object : Callback {
+                override fun onFailure(call: Call, e: IOException) {
+                    runOnUiThread {
+                        setStatus("❌ API Error: ${e.message}")
+                    }
+                }
+
+                override fun onResponse(call: Call, response: Response) {
+                    val responseBody = response.body?.string()
+                    response.close()
+
+                    runOnUiThread {
+                        if (response.isSuccessful) {
+                            Log.d("ThreeDSTest", "Auth Response: $responseBody")
+                            try {
+                                val jsonResponse = JSONObject(responseBody ?: "")
+                                val transStatus = jsonResponse.optString("trans_status", "")
+                                
+                                if (transStatus == "C") {
+                                    // Challenge required - extract challenge parameters
+                                    challengeParameters = ChallengeParameters(
+                                        threeDSServerTransactionId = jsonResponse.optString("three_ds_server_transaction_id", ""),
+                                        acsTransactionId = jsonResponse.optString("acs_trans_id", ""),
+                                        acsReferenceNumber = jsonResponse.optString("acs_reference_number", ""),
+                                        acsSignedContent = jsonResponse.optString("acs_signed_content", ""),
+                                        threeDSRequestorAppURL = jsonResponse.optString("three_ds_requestor_app_url", ""),
+                                        transStatus = transStatus
+                                    )
+                                    setStatus("✅ Challenge required - Status: $transStatus")
+                                } else {
+                                    setStatus("✅ Authentication completed - Status: $transStatus")
+                                }
+                            } catch (e: Exception) {
+                                setStatus("❌ Error parsing response: ${e.message}")
+                            }
+                        } else {
+                            setStatus("❌ API Error: ${response.code} - ${response.message}")
+                        }
+                    }
+                }
+            })
+
+        } catch (e: Exception) {
+            setStatus("❌ Error making authentication API call: ${e.message}")
+            Log.e("ThreeDSTest", "Error in makeAuthenticationApiCall", e)
+        }
+    }
+
+    private fun performChallenge() {
+        try {
+            if (session == null || transaction == null) {
+                setStatus("❌ Error: Please complete previous steps first")
+                return
+            }
+
+            // Check if challenge is required based on transaction status
+            if (challengeParameters != null && challengeParameters!!.transStatus == "C") {
+                setStatus("🔄 Challenge required, starting challenge flow...")
+
+                val challengeStatusReceiver = object : ChallengeStatusReceiver {
+                    override fun completed(completionEvent: CompletionEvent) {
+                        setStatus("✅ Challenge completed successfully - Transaction ID: ${completionEvent.transactionId}")
+                    }
+
+                    override fun cancelled() {
+                        setStatus("🚫 Challenge cancelled by user")
+                    }
+
+                    override fun timedout() {
+                        setStatus("⏰ Challenge timed out")
+                    }
+
+                    override fun protocolError(protocolErrorEvent: ProtocolErrorEvent) {
+                        setStatus("❌ Protocol error - Error: ${protocolErrorEvent.errorMessage.errorDescription}")
+                    }
+
+                    override fun runtimeError(runtimeErrorEvent: RuntimeErrorEvent) {
+                        setStatus("❌ Runtime error - Error: ${runtimeErrorEvent.errorMessage}")
+                    }
+                }
+
                 runOnUiThread {
-                    statusText.text = "Authentication cancelled by user"
-                    Toast.makeText(this@MainActivity, "Authentication cancelled", Toast.LENGTH_SHORT).show()
+                    transaction!!.doChallenge(
+                        activity = this@MainActivity,
+                        challengeParameters = challengeParameters!!,
+                        challengeStatusReceiver = challengeStatusReceiver,
+                        timeout = 5
+                    )
                 }
-                Log.d("3DS_DEMO", "Authentication cancelled")
+
+            } else {
+                val status = challengeParameters?.transStatus ?: "unknown"
+                setStatus("✅ No challenge required - Status: $status")
             }
-        })
+
+        } catch (e: Exception) {
+            setStatus("❌ Error performing challenge: ${e.message}")
+            Log.e("ThreeDSTest", "Error in performChallenge", e)
+        }
     }
-    
-    override fun onDestroy() {
-        super.onDestroy()
-        threeDSManager.cleanup()
+
+    private fun setStatus(message: String) {
+        runOnUiThread {
+            statusText.text = message
+            Log.d("ThreeDSTest", message)
+        }
     }
 }
diff --git a/app/src/main/res/layout/activity_main.xml b/app/src/main/res/layout/activity_main.xml
new file mode 100644
index 0000000..e8ca1d9
--- /dev/null
+++ b/app/src/main/res/layout/activity_main.xml
@@ -0,0 +1,55 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:padding="16dp"
+    android:gravity="center">
+
+    <TextView
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="Unified 3DS Demo"
+        android:textSize="24sp"
+        android:textStyle="bold"
+        android:layout_marginBottom="32dp" />
+
+    <TextView
+        android:id="@+id/statusText"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="Ready to test 3DS authentication"
+        android:textSize="16sp"
+        android:gravity="center"
+        android:layout_marginBottom="32dp"
+        android:minHeight="100dp" />
+
+    <Button
+        android:id="@+id/btnInit3DS"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="1. Initialize 3DS"
+        android:layout_marginBottom="8dp" />
+
+    <Button
+        android:id="@+id/btnGenerateAReq"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="2. Create Transaction &amp; Get AReq"
+        android:layout_marginBottom="8dp" />
+
+    <Button
+        android:id="@+id/btnReceiveChallenge"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="3. Make Authentication API Call"
+        android:layout_marginBottom="8dp" />
+
+    <Button
+        android:id="@+id/btnDoChallenge"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="4. Perform Challenge"
+        android:layout_marginBottom="8dp" />
+
+</LinearLayout>
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/ThreeDSManager.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/ThreeDSManager.kt
index 083c380..3b61a42 100644
--- a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/ThreeDSManager.kt
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/ThreeDSManager.kt
@@ -2,9 +2,11 @@ package io.hyperswitch.modular_3ds
 
 import android.content.Context
 import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.callbacks.AuthParametersCallback
 import io.hyperswitch.modular_3ds.callbacks.AuthenticationCallback
 import io.hyperswitch.modular_3ds.callbacks.ChallengeCallback
 import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
+import io.hyperswitch.modular_3ds.callbacks.TransactionCallback
 import io.hyperswitch.modular_3ds.models.*
 import io.hyperswitch.modular_3ds.provider.ProviderFactory
 import io.hyperswitch.modular_3ds.provider.ProviderRegistry
@@ -146,10 +148,61 @@ class ThreeDSManager private constructor() {
     }
     
     /**
-     * Handle challenge flow when required.
+     * Create a 3DS transaction.
+     * This is the first step in the 3DS authentication flow.
      */
     @Keep
-    fun handleChallenge(
+    fun createTransaction(
+        request: TransactionRequest,
+        callback: TransactionCallback
+    ) {
+        val provider = currentProvider
+        if (provider == null || !isInitialized) {
+            callback.onTransactionFailure(
+                ThreeDSError(
+                    code = "NOT_INITIALIZED",
+                    message = "ThreeDSManager is not initialized",
+                    details = "Call initialize() first",
+                    errorType = ErrorType.CONFIGURATION_ERROR
+                )
+            )
+            return
+        }
+        
+        provider.createTransaction(request, callback)
+    }
+    
+    /**
+     * Get authentication request parameters for the transaction.
+     * These parameters are sent to the 3DS Server for authentication.
+     */
+    @Keep
+    fun getAuthenticationRequestParameters(
+        transactionId: String,
+        callback: AuthParametersCallback
+    ) {
+        val provider = currentProvider
+        if (provider == null || !isInitialized) {
+            callback.onAuthParametersFailure(
+                ThreeDSError(
+                    code = "NOT_INITIALIZED",
+                    message = "ThreeDSManager is not initialized",
+                    details = "Call initialize() first",
+                    errorType = ErrorType.CONFIGURATION_ERROR
+                )
+            )
+            return
+        }
+        
+        provider.getAuthenticationRequestParameters(transactionId, callback)
+    }
+    
+    /**
+     * Handle challenge flow when required by the issuer.
+     * This is the 4th core function in the 3DS flow.
+     */
+    @Keep
+    fun doChallenge(
         parameters: ChallengeParameters,
         callback: ChallengeCallback
     ) {
@@ -166,7 +219,20 @@ class ThreeDSManager private constructor() {
             return
         }
         
-        provider.handleChallenge(parameters, callback)
+        provider.doChallenge(parameters, callback)
+    }
+    
+    /**
+     * Handle challenge flow when required.
+     * @deprecated Use doChallenge instead for consistency with 4 core functions pattern.
+     */
+    @Keep
+    @Deprecated("Use doChallenge instead", ReplaceWith("doChallenge(parameters, callback)"))
+    fun handleChallenge(
+        parameters: ChallengeParameters,
+        callback: ChallengeCallback
+    ) {
+        doChallenge(parameters, callback)
     }
     
     /**
@@ -177,6 +243,15 @@ class ThreeDSManager private constructor() {
         return currentProvider?.getProviderName()
     }
     
+    /**
+     * Get the currently active provider instance.
+     * This is used internally by the unified API for provider-specific operations.
+     */
+    @Keep
+    fun getCurrentProviderInstance(): ThreeDSProvider? {
+        return currentProvider
+    }
+    
     /**
      * Check if the manager is initialized and ready to use.
      */
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationConfiguration.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationConfiguration.kt
new file mode 100644
index 0000000..b4c7a9c
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationConfiguration.kt
@@ -0,0 +1,13 @@
+package io.hyperswitch.modular_3ds.api
+
+import io.hyperswitch.modular_3ds.models.ThreeDSEnvironment
+import io.hyperswitch.modular_3ds.models.UiCustomization
+
+/**
+ * Configuration for 3DS authentication session
+ */
+data class AuthenticationConfiguration(
+    val apiKey: String,
+    val environment: ThreeDSEnvironment,
+    val uiCustomization: UiCustomization? = null
+)
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationRequestParameters.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationRequestParameters.kt
new file mode 100644
index 0000000..7bb1bd9
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationRequestParameters.kt
@@ -0,0 +1,13 @@
+package io.hyperswitch.modular_3ds.api
+
+/**
+ * Authentication request parameters for 3DS
+ */
+data class AuthenticationRequestParameters(
+    val sdkTransactionID: String,
+    val sdkAppID: String,
+    val sdkReferenceNumber: String,
+    val sdkEphemeralPublicKey: String?,
+    val deviceData: String,
+    val sdkMaxTimeout: Int = 5
+)
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationResult.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationResult.kt
new file mode 100644
index 0000000..5f8b88f
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/AuthenticationResult.kt
@@ -0,0 +1,10 @@
+package io.hyperswitch.modular_3ds.api
+
+/**
+ * Result of authentication operations
+ */
+sealed class AuthenticationResult {
+    object Success : AuthenticationResult()
+    data class Error(val message: String) : AuthenticationResult()
+    object Challenge : AuthenticationResult()
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ChallengeEvents.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ChallengeEvents.kt
new file mode 100644
index 0000000..4238528
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ChallengeEvents.kt
@@ -0,0 +1,40 @@
+package io.hyperswitch.modular_3ds.api
+
+/**
+ * Challenge completion event
+ */
+data class CompletionEvent(
+    val transactionId: String
+)
+
+/**
+ * Protocol error event during challenge
+ */
+data class ProtocolErrorEvent(
+    val errorMessage: ErrorMessage
+)
+
+/**
+ * Runtime error event during challenge
+ */
+data class RuntimeErrorEvent(
+    val errorMessage: String
+)
+
+/**
+ * Error message details
+ */
+data class ErrorMessage(
+    val errorDescription: String
+)
+
+/**
+ * Challenge status receiver interface
+ */
+interface ChallengeStatusReceiver {
+    fun completed(completionEvent: CompletionEvent)
+    fun cancelled()
+    fun timedout()
+    fun protocolError(protocolErrorEvent: ProtocolErrorEvent)
+    fun runtimeError(runtimeErrorEvent: RuntimeErrorEvent)
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSAuthenticationSession.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSAuthenticationSession.kt
new file mode 100644
index 0000000..162850b
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSAuthenticationSession.kt
@@ -0,0 +1,87 @@
+package io.hyperswitch.modular_3ds.api
+
+import android.app.Activity
+import android.content.Context
+import io.hyperswitch.modular_3ds.ThreeDSManager
+import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
+import io.hyperswitch.modular_3ds.models.ThreeDSConfiguration
+import io.hyperswitch.modular_3ds.models.ThreeDSError
+import io.hyperswitch.modular_3ds.provider.ProviderRegistry
+
+/**
+ * Main entry point for unified 3DS authentication
+ */
+class ThreeDSAuthenticationSession(
+    private val activity: Activity,
+    private val publishKey: String
+) {
+    
+    private val threeDSManager = ThreeDSManager.getInstance()
+    
+    /**
+     * Initialize 3DS session
+     */
+    fun initThreeDsSession(
+        authIntentClientSecret: String,
+        configuration: AuthenticationConfiguration,
+        callback: (AuthenticationResult) -> Unit
+    ): ThreeDSSession? {
+        
+        // Convert unified configuration to internal configuration
+        val internalConfig = ThreeDSConfiguration.Builder()
+            .setEnvironment(configuration.environment)
+            .setEnableLogging(true)
+            .apply {
+                configuration.uiCustomization?.let { setUiCustomization(it) }
+            }
+            .build()
+        
+        var session: ThreeDSSession? = null
+        val semaphore = java.util.concurrent.Semaphore(0)
+        
+        threeDSManager.initialize(activity, internalConfig, object : InitializationCallback {
+            override fun onInitializationSuccess() {
+                // Initialize provider with context if needed
+                val provider = threeDSManager.getCurrentProvider()
+                if (provider == "trident") {
+                    try {
+                        // Get the current provider instance from ThreeDSManager
+                        val currentProviderInstance = threeDSManager.getCurrentProviderInstance()
+                        
+                        // Use reflection to call initializeWithContext to avoid direct dependency
+                        currentProviderInstance?.let { providerInstance ->
+                            try {
+                                val method = providerInstance.javaClass.getMethod("initializeWithContext", Context::class.java)
+                                method.invoke(providerInstance, activity)
+                            } catch (e: NoSuchMethodException) {
+                                // Method doesn't exist, which is fine for non-Trident providers
+                            }
+                        }
+                    } catch (e: Exception) {
+                        callback(AuthenticationResult.Error("Failed to initialize provider with context: ${e.message}"))
+                        semaphore.release()
+                        return
+                    }
+                }
+                
+                session = ThreeDSSession(threeDSManager)
+                callback(AuthenticationResult.Success)
+                semaphore.release()
+            }
+            
+            override fun onInitializationFailure(error: ThreeDSError) {
+                callback(AuthenticationResult.Error(error.message))
+                semaphore.release()
+            }
+        })
+        
+        // Wait for initialization to complete
+        try {
+            semaphore.acquire()
+        } catch (e: InterruptedException) {
+            return null
+        }
+        
+        return session
+    }
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSSession.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSSession.kt
new file mode 100644
index 0000000..26d181e
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSSession.kt
@@ -0,0 +1,55 @@
+package io.hyperswitch.modular_3ds.api
+
+import io.hyperswitch.modular_3ds.ThreeDSManager
+import io.hyperswitch.modular_3ds.callbacks.TransactionCallback
+import io.hyperswitch.modular_3ds.models.ThreeDSError
+import io.hyperswitch.modular_3ds.models.TransactionRequest
+
+/**
+ * Unified session for 3DS authentication
+ */
+class ThreeDSSession internal constructor(
+    private val threeDSManager: ThreeDSManager
+) {
+    
+    /**
+     * Create a transaction for 3DS authentication
+     */
+    fun createTransaction(
+        directoryServerId: String?,
+        messageVersion: String,
+        cardNetwork: String
+    ): ThreeDSTransaction? {
+        var transaction: ThreeDSTransaction? = null
+        
+        val transactionRequest = TransactionRequest(
+            messageVersion = messageVersion,
+            directoryServerId = directoryServerId,
+            cardNetwork = cardNetwork
+        )
+        
+        // Use a blocking approach for simplicity in the unified API
+        val semaphore = java.util.concurrent.Semaphore(0)
+        
+        threeDSManager.createTransaction(transactionRequest, object : TransactionCallback {
+            override fun onTransactionSuccess(response: io.hyperswitch.modular_3ds.models.TransactionResponse) {
+                transaction = ThreeDSTransaction(response.transactionId, threeDSManager)
+                semaphore.release()
+            }
+            
+            override fun onTransactionFailure(error: ThreeDSError) {
+                transaction = null
+                semaphore.release()
+            }
+        })
+        
+        // Wait for the transaction creation to complete
+        try {
+            semaphore.acquire()
+        } catch (e: InterruptedException) {
+            return null
+        }
+        
+        return transaction
+    }
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSTransaction.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSTransaction.kt
new file mode 100644
index 0000000..72e701d
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/api/ThreeDSTransaction.kt
@@ -0,0 +1,82 @@
+package io.hyperswitch.modular_3ds.api
+
+import android.app.Activity
+import io.hyperswitch.modular_3ds.ThreeDSManager
+import io.hyperswitch.modular_3ds.callbacks.AuthParametersCallback
+import io.hyperswitch.modular_3ds.callbacks.ChallengeCallback
+import io.hyperswitch.modular_3ds.models.ChallengeWindowSize
+import io.hyperswitch.modular_3ds.models.ThreeDSError
+import io.hyperswitch.modular_3ds.models.ChallengeParameters
+
+/**
+ * Unified transaction for 3DS authentication
+ */
+class ThreeDSTransaction internal constructor(
+    private val transactionId: String,
+    private val threeDSManager: ThreeDSManager
+) {
+    
+    /**
+     * Get authentication request parameters
+     */
+    fun getAuthenticationRequestParameters(callback: (AuthenticationRequestParameters?) -> Unit) {
+        threeDSManager.getAuthenticationRequestParameters(transactionId, object : AuthParametersCallback {
+            override fun onAuthParametersSuccess(parameters: io.hyperswitch.modular_3ds.models.AuthenticationParameters) {
+                val unifiedParams = AuthenticationRequestParameters(
+                    sdkTransactionID = parameters.sdkTransactionId,
+                    sdkAppID = parameters.sdkAppId,
+                    sdkReferenceNumber = parameters.sdkReferenceNumber,
+                    sdkEphemeralPublicKey = parameters.sdkEphemeralPublicKey,
+                    deviceData = parameters.deviceData
+                )
+                callback(unifiedParams)
+            }
+            
+            override fun onAuthParametersFailure(error: ThreeDSError) {
+                callback(null)
+            }
+        })
+    }
+    
+    /**
+     * Perform challenge flow
+     */
+    fun doChallenge(
+        activity: Activity,
+        challengeParameters: ChallengeParameters,
+        challengeStatusReceiver: ChallengeStatusReceiver,
+        timeout: Int
+    ) {
+        // Use the challenge parameters directly since we now have a unified model
+        val internalChallengeParams = challengeParameters
+        
+        // Convert unified challenge status receiver to internal format
+        val internalCallback = object : ChallengeCallback {
+            override fun onChallengeSuccess(result: io.hyperswitch.modular_3ds.models.ChallengeResult) {
+                challengeStatusReceiver.completed(CompletionEvent(result.transactionId))
+            }
+            
+            override fun onChallengeCancelled() {
+                challengeStatusReceiver.cancelled()
+            }
+            
+            override fun onChallengeFailure(error: ThreeDSError) {
+                when (error.code) {
+                    "CHALLENGE_TIMEOUT" -> challengeStatusReceiver.timedout()
+                    "PROTOCOL_ERROR" -> challengeStatusReceiver.protocolError(
+                        ProtocolErrorEvent(ErrorMessage(error.message))
+                    )
+                    else -> challengeStatusReceiver.runtimeError(
+                        RuntimeErrorEvent(error.message)
+                    )
+                }
+            }
+            
+            override fun onChallengeTimeout() {
+                challengeStatusReceiver.timedout()
+            }
+        }
+        
+        threeDSManager.doChallenge(internalChallengeParams, internalCallback)
+    }
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/AuthParametersCallback.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/AuthParametersCallback.kt
new file mode 100644
index 0000000..199371e
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/AuthParametersCallback.kt
@@ -0,0 +1,24 @@
+package io.hyperswitch.modular_3ds.callbacks
+
+import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.models.AuthenticationParameters
+import io.hyperswitch.modular_3ds.models.ThreeDSError
+
+/**
+ * Callback interface for getting authentication request parameters.
+ */
+@Keep
+interface AuthParametersCallback {
+    
+    /**
+     * Called when authentication parameters are successfully retrieved.
+     */
+    @Keep
+    fun onAuthParametersSuccess(parameters: AuthenticationParameters)
+    
+    /**
+     * Called when getting authentication parameters fails.
+     */
+    @Keep
+    fun onAuthParametersFailure(error: ThreeDSError)
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/ChallengeCallback.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/ChallengeCallback.kt
index d42392e..bc82635 100644
--- a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/ChallengeCallback.kt
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/ChallengeCallback.kt
@@ -9,29 +9,29 @@ import io.hyperswitch.modular_3ds.models.ThreeDSError
  */
 @Keep
 interface ChallengeCallback {
-    
+
     /**
      * Called when the challenge flow is completed successfully.
-     * 
+     *
      * @param result The challenge result containing authentication outcome
      */
     @Keep
     fun onChallengeSuccess(result: ChallengeResult)
-    
+
     /**
      * Called when the challenge flow fails.
-     * 
+     *
      * @param error Details about the challenge failure
      */
     @Keep
     fun onChallengeFailure(error: ThreeDSError)
-    
+
     /**
      * Called when the challenge flow is cancelled by the user.
      */
     @Keep
     fun onChallengeCancelled()
-    
+
     /**
      * Called when the challenge UI times out.
      */
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/TransactionCallback.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/TransactionCallback.kt
new file mode 100644
index 0000000..4e55150
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/callbacks/TransactionCallback.kt
@@ -0,0 +1,24 @@
+package io.hyperswitch.modular_3ds.callbacks
+
+import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.models.ThreeDSError
+import io.hyperswitch.modular_3ds.models.TransactionResponse
+
+/**
+ * Callback interface for transaction creation operations.
+ */
+@Keep
+interface TransactionCallback {
+    
+    /**
+     * Called when transaction creation is successful.
+     */
+    @Keep
+    fun onTransactionSuccess(response: TransactionResponse)
+    
+    /**
+     * Called when transaction creation fails.
+     */
+    @Keep
+    fun onTransactionFailure(error: ThreeDSError)
+}
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ChallengeParameters.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ChallengeParameters.kt
index f279685..96a5405 100644
--- a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ChallengeParameters.kt
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ChallengeParameters.kt
@@ -11,8 +11,10 @@ data class ChallengeParameters(
     @Keep val acsTransactionId: String,
     @Keep val acsReferenceNumber: String,
     @Keep val acsSignedContent: String,
-    @Keep val challengeWindowSize: ChallengeWindowSize,
-    @Keep val timeout: Long = 30000L
+    @Keep val challengeWindowSize: ChallengeWindowSize = ChallengeWindowSize.FULL_SCREEN,
+    @Keep val timeout: Long = 30000L,
+    @Keep val threeDSRequestorAppURL: String? = null,
+    @Keep val transStatus: String
 )
 
 /**
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ThreeDSConfiguration.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ThreeDSConfiguration.kt
index 6c155a9..772dc12 100644
--- a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ThreeDSConfiguration.kt
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/ThreeDSConfiguration.kt
@@ -57,9 +57,6 @@ data class ThreeDSConfiguration private constructor(
         
         @Keep
         fun build(): ThreeDSConfiguration {
-            require(directoryServerId.isNotEmpty()) {
-                "Directory Server ID is required"
-            }
             require(timeout > 0) {
                 "Timeout must be positive"
             }
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/TransactionRequest.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/TransactionRequest.kt
new file mode 100644
index 0000000..6dddd67
--- /dev/null
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/models/TransactionRequest.kt
@@ -0,0 +1,49 @@
+package io.hyperswitch.modular_3ds.models
+
+import androidx.annotation.Keep
+
+/**
+ * Transaction request for creating a 3DS transaction.
+ * This is the first step in the 3DS authentication flow.
+ * Matches the merchant implementation pattern: createTransaction(directoryServerId, messageVersion, cardNetwork)
+ */
+@Keep
+data class TransactionRequest(
+    @Keep val messageVersion: String,        // From eligibility API response
+    @Keep val directoryServerId: String?,    // From eligibility API response
+    @Keep val cardNetwork: String?           // Merchant specifies: "VISA", "MASTERCARD", etc.
+)
+
+/**
+ * Response from creating a 3DS transaction.
+ */
+@Keep
+data class TransactionResponse(
+    @Keep val transactionId: String,
+    @Keep val sdkTransactionId: String,
+    @Keep val serverTransactionId: String,
+    @Keep val acsTransactionId: String?,
+    @Keep val dsTransactionId: String?,
+    @Keep val messageVersion: String,
+    @Keep val deviceData: String?,
+    @Keep val sdkAppId: String?,
+    @Keep val sdkEncryptionData: String?,
+    @Keep val sdkEphemeralPublicKey: String?,
+    @Keep val sdkReferenceNumber: String?
+)
+
+/**
+ * Authentication parameters returned from getAuthenticationRequestParameters.
+ * These parameters are sent to the 3DS Server for authentication.
+ */
+@Keep
+data class AuthenticationParameters(
+    @Keep val deviceData: String,
+    @Keep val sdkTransactionId: String,
+    @Keep val sdkAppId: String,
+    @Keep val sdkEncryptionData: String,
+    @Keep val sdkEphemeralPublicKey: String,
+    @Keep val sdkReferenceNumber: String,
+    @Keep val messageVersion: String,
+    @Keep val threeDSCompInd: String?
+)
diff --git a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/provider/ThreeDSProvider.kt b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/provider/ThreeDSProvider.kt
index 447650c..8baa627 100644
--- a/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/provider/ThreeDSProvider.kt
+++ b/modular-3ds-api/src/main/java/io/hyperswitch/modular_3ds/provider/ThreeDSProvider.kt
@@ -1,12 +1,15 @@
 package io.hyperswitch.modular_3ds.provider
 
 import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.callbacks.AuthParametersCallback
 import io.hyperswitch.modular_3ds.callbacks.AuthenticationCallback
 import io.hyperswitch.modular_3ds.callbacks.ChallengeCallback
 import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
+import io.hyperswitch.modular_3ds.callbacks.TransactionCallback
 import io.hyperswitch.modular_3ds.models.AuthenticationRequest
 import io.hyperswitch.modular_3ds.models.ChallengeParameters
 import io.hyperswitch.modular_3ds.models.ThreeDSConfiguration
+import io.hyperswitch.modular_3ds.models.TransactionRequest
 
 /**
  * Core interface that all 3DS providers must implement.
@@ -54,12 +57,33 @@ interface ThreeDSProvider {
         callback: AuthenticationCallback
     )
     
+    /**
+     * Create a 3DS transaction.
+     * This is the first step in the 3DS authentication flow.
+     */
+    @Keep
+    fun createTransaction(
+        request: TransactionRequest,
+        callback: TransactionCallback
+    )
+    
+    /**
+     * Get authentication request parameters for the transaction.
+     * These parameters are sent to the 3DS Server for authentication.
+     */
+    @Keep
+    fun getAuthenticationRequestParameters(
+        transactionId: String,
+        callback: AuthParametersCallback
+    )
+    
     /**
      * Handle challenge flow when required by the issuer.
      * This presents the challenge UI to the user.
+     * Renamed from handleChallenge to match the 4 core functions pattern.
      */
     @Keep
-    fun handleChallenge(
+    fun doChallenge(
         parameters: ChallengeParameters,
         callback: ChallengeCallback
     )
diff --git a/modular-3ds-mock/src/main/java/io/hyperswitch/modular_3ds/mock/MockThreeDSProvider.kt b/modular-3ds-mock/src/main/java/io/hyperswitch/modular_3ds/mock/MockThreeDSProvider.kt
index e9f3ce9..ccae8f5 100644
--- a/modular-3ds-mock/src/main/java/io/hyperswitch/modular_3ds/mock/MockThreeDSProvider.kt
+++ b/modular-3ds-mock/src/main/java/io/hyperswitch/modular_3ds/mock/MockThreeDSProvider.kt
@@ -1,9 +1,11 @@
 package io.hyperswitch.modular_3ds.mock
 
 import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.callbacks.AuthParametersCallback
 import io.hyperswitch.modular_3ds.callbacks.AuthenticationCallback
 import io.hyperswitch.modular_3ds.callbacks.ChallengeCallback
 import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
+import io.hyperswitch.modular_3ds.callbacks.TransactionCallback
 import io.hyperswitch.modular_3ds.models.*
 import io.hyperswitch.modular_3ds.provider.ThreeDSProvider
 import kotlinx.coroutines.*
@@ -24,13 +26,8 @@ class MockThreeDSProvider : ThreeDSProvider {
         callback: InitializationCallback
     ) {
         this.configuration = configuration
-        
-        // Simulate initialization delay
-        scope.launch {
-            delay(500)
-            isInitialized = true
-            callback.onInitializationSuccess()
-        }
+        isInitialized = true
+        callback.onInitializationSuccess()
     }
     
     override fun isInitialized(): Boolean = isInitialized
@@ -55,11 +52,7 @@ class MockThreeDSProvider : ThreeDSProvider {
             return
         }
         
-        scope.launch {
-            // Simulate network delay
-            delay(1000)
-            
-            // Simulate different scenarios based on card number
+        // Simulate different scenarios based on card number
             when {
                 request.cardNumber.endsWith("0000") -> {
                     // Simulate frictionless success
diff --git a/modular-3ds-netcetera/src/main/java/io/hyperswitch/modular_3ds/netcetera/NetceteraThreeDSProvider.kt b/modular-3ds-netcetera/src/main/java/io/hyperswitch/modular_3ds/netcetera/NetceteraThreeDSProvider.kt
index 29cc31d..d652638 100644
--- a/modular-3ds-netcetera/src/main/java/io/hyperswitch/modular_3ds/netcetera/NetceteraThreeDSProvider.kt
+++ b/modular-3ds-netcetera/src/main/java/io/hyperswitch/modular_3ds/netcetera/NetceteraThreeDSProvider.kt
@@ -1,14 +1,17 @@
 package io.hyperswitch.modular_3ds.netcetera
 
 import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.callbacks.AuthParametersCallback
 import io.hyperswitch.modular_3ds.callbacks.AuthenticationCallback
 import io.hyperswitch.modular_3ds.callbacks.ChallengeCallback
 import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
+import io.hyperswitch.modular_3ds.callbacks.TransactionCallback
 import io.hyperswitch.modular_3ds.models.AuthenticationRequest
 import io.hyperswitch.modular_3ds.models.AuthenticationResponse
 import io.hyperswitch.modular_3ds.models.AuthenticationStatus
 import io.hyperswitch.modular_3ds.models.ChallengeParameters
 import io.hyperswitch.modular_3ds.models.ThreeDSConfiguration
+import io.hyperswitch.modular_3ds.models.TransactionRequest
 import io.hyperswitch.modular_3ds.provider.ThreeDSProvider
 
 /**
@@ -23,25 +26,6 @@ class NetceteraThreeDSProvider : ThreeDSProvider {
     
     override fun initialize(configuration: ThreeDSConfiguration, callback: InitializationCallback) {
         try {
-            // TODO: Initialize Netcetera SDK with proper configuration
-            // This will need to be implemented based on Netcetera SDK documentation
-            // Example structure:
-            // val netceteraConfig = NetceteraConfig.Builder()
-            //     .setEnvironment(if (configuration.isProduction) Environment.PRODUCTION else Environment.SANDBOX)
-            //     .setApiKey(configuration.apiKey)
-            //     .build()
-            // 
-            // NetceteraSDK.initialize(context, netceteraConfig) { success ->
-            //     if (success) {
-            //         this.configuration = configuration
-            //         this.isInitialized = true
-            //         callback.onSuccess()
-            //     } else {
-            //         callback.onError(Exception("Failed to initialize Netcetera SDK"))
-            //     }
-            // }
-            
-            // Placeholder implementation
             this.configuration = configuration
             this.isInitialized = true
             callback.onInitializationSuccess()
@@ -60,7 +44,7 @@ class NetceteraThreeDSProvider : ThreeDSProvider {
     
     override fun isInitialized(): Boolean = isInitialized
     
-    override fun getSDKVersion(): String = "2.5.2.0"
+    override fun getSDKVersion(): String = "Netcetera-SDK"
     
     override fun getProviderName(): String = "Netcetera"
     
@@ -128,7 +112,7 @@ class NetceteraThreeDSProvider : ThreeDSProvider {
                 dsTransactionId = "placeholder_ds_trans_id",
                 acsTransactionId = "placeholder_acs_trans_id",
                 threeDSServerTransactionId = "placeholder_3ds_server_trans_id",
-                messageVersion = "2.2.0",
+                messageVersion = "2.1.0",
                 challengeRequired = false,
                 liabilityShift = true,
                 statusReason = null
@@ -147,7 +131,94 @@ class NetceteraThreeDSProvider : ThreeDSProvider {
         }
     }
     
-    override fun handleChallenge(parameters: ChallengeParameters, callback: ChallengeCallback) {
+    override fun createTransaction(request: TransactionRequest, callback: TransactionCallback) {
+        if (!isInitialized) {
+            callback.onTransactionFailure(
+                io.hyperswitch.modular_3ds.models.ThreeDSError(
+                    code = "TRANS_001",
+                    message = "Provider not initialized. Call initialize() first.",
+                    details = null,
+                    errorType = io.hyperswitch.modular_3ds.models.ErrorType.PROVIDER_ERROR
+                )
+            )
+            return
+        }
+        
+        try {
+            // TODO: Implement actual Netcetera transaction creation
+            // This will need to be implemented based on Netcetera SDK documentation
+            
+            // Placeholder implementation
+            val response = io.hyperswitch.modular_3ds.models.TransactionResponse(
+                transactionId = "netcetera_txn_${System.currentTimeMillis()}",
+                sdkTransactionId = "netcetera_sdk_txn_${System.currentTimeMillis()}",
+                serverTransactionId = "netcetera_server_txn_${System.currentTimeMillis()}",
+                acsTransactionId = "netcetera_acs_txn_${System.currentTimeMillis()}",
+                dsTransactionId = "netcetera_ds_txn_${System.currentTimeMillis()}",
+                messageVersion = "2.1.0",
+                deviceData = "netcetera_device_data_${System.currentTimeMillis()}",
+                sdkAppId = "netcetera_app_id",
+                sdkEncryptionData = "netcetera_encryption_data",
+                sdkEphemeralPublicKey = "netcetera_ephemeral_key",
+                sdkReferenceNumber = "netcetera_ref_${System.currentTimeMillis()}"
+            )
+            callback.onTransactionSuccess(response)
+            
+        } catch (e: Exception) {
+            callback.onTransactionFailure(
+                io.hyperswitch.modular_3ds.models.ThreeDSError(
+                    code = "TRANS_002",
+                    message = "Transaction creation failed",
+                    details = e.message,
+                    errorType = io.hyperswitch.modular_3ds.models.ErrorType.PROVIDER_ERROR
+                )
+            )
+        }
+    }
+    
+    override fun getAuthenticationRequestParameters(transactionId: String, callback: AuthParametersCallback) {
+        if (!isInitialized) {
+            callback.onAuthParametersFailure(
+                io.hyperswitch.modular_3ds.models.ThreeDSError(
+                    code = "PARAMS_001",
+                    message = "Provider not initialized. Call initialize() first.",
+                    details = null,
+                    errorType = io.hyperswitch.modular_3ds.models.ErrorType.PROVIDER_ERROR
+                )
+            )
+            return
+        }
+        
+        try {
+            // TODO: Implement actual Netcetera authentication parameters retrieval
+            // This will need to be implemented based on Netcetera SDK documentation
+            
+            // Placeholder implementation
+            val parameters = io.hyperswitch.modular_3ds.models.AuthenticationParameters(
+                deviceData = "netcetera_device_data_${System.currentTimeMillis()}",
+                sdkTransactionId = transactionId,
+                sdkAppId = "netcetera_app_id",
+                sdkEncryptionData = "netcetera_encryption_data",
+                sdkEphemeralPublicKey = "netcetera_ephemeral_key",
+                sdkReferenceNumber = "netcetera_ref_${System.currentTimeMillis()}",
+                messageVersion = "2.1.0",
+                threeDSCompInd = "Y"
+            )
+            callback.onAuthParametersSuccess(parameters)
+            
+        } catch (e: Exception) {
+            callback.onAuthParametersFailure(
+                io.hyperswitch.modular_3ds.models.ThreeDSError(
+                    code = "PARAMS_002",
+                    message = "Failed to get authentication parameters",
+                    details = e.message,
+                    errorType = io.hyperswitch.modular_3ds.models.ErrorType.PROVIDER_ERROR
+                )
+            )
+        }
+    }
+    
+    override fun doChallenge(parameters: ChallengeParameters, callback: ChallengeCallback) {
         if (!isInitialized) {
             callback.onChallengeFailure(
                 io.hyperswitch.modular_3ds.models.ThreeDSError(
@@ -164,11 +235,11 @@ class NetceteraThreeDSProvider : ThreeDSProvider {
             // TODO: Implement actual Netcetera challenge flow
             // This will need to be implemented based on Netcetera SDK documentation
             
-            // Placeholder implementation - need to create ChallengeResult
+            // Placeholder implementation
             val challengeResult = io.hyperswitch.modular_3ds.models.ChallengeResult(
-                transactionId = "challenge_${System.currentTimeMillis()}",
+                transactionId = parameters.threeDSServerTransactionId,
                 status = io.hyperswitch.modular_3ds.models.AuthenticationStatus.Y,
-                authenticationValue = "placeholder_auth_value",
+                authenticationValue = "netcetera_challenge_result_${System.currentTimeMillis()}",
                 eci = "05"
             )
             callback.onChallengeSuccess(challengeResult)
@@ -185,6 +256,10 @@ class NetceteraThreeDSProvider : ThreeDSProvider {
         }
     }
     
+    override fun handleChallenge(parameters: ChallengeParameters, callback: ChallengeCallback) {
+        doChallenge(parameters, callback)
+    }
+    
     override fun cleanup() {
         try {
             // TODO: Cleanup Netcetera SDK resources
diff --git a/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentConfigurator.kt b/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentConfigurator.kt
new file mode 100644
index 0000000..6280a5c
--- /dev/null
+++ b/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentConfigurator.kt
@@ -0,0 +1,28 @@
+package io.hyperswitch.modular_3ds.trident
+
+import `in`.juspay.trident.core.ConfigParameters
+
+/**
+ * Configurator class for Trident SDK configuration parameters.
+ * Similar to HsTridentConfigurator from the example.
+ */
+object TridentConfigurator {
+    
+    lateinit var configParams: ConfigParameters
+        private set
+    
+    /**
+     * Set up configuration parameters for Trident SDK.
+     * This should be called before initializing the SDK.
+     */
+    fun setConfigParameters() {
+        configParams = ConfigParameters()
+    }
+    
+    /**
+     * Check if configuration parameters have been set.
+     */
+    fun isConfigured(): Boolean {
+        return ::configParams.isInitialized
+    }
+}
diff --git a/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentThreeDSProvider.kt b/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentThreeDSProvider.kt
index 93cb844..489c14d 100644
--- a/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentThreeDSProvider.kt
+++ b/modular-3ds-trident/src/main/java/io/hyperswitch/modular_3ds/trident/TridentThreeDSProvider.kt
@@ -1,14 +1,31 @@
 package io.hyperswitch.modular_3ds.trident
 
+import android.app.Activity
+import android.content.Context
 import android.os.Handler
 import android.os.Looper
+import android.util.Log
 import androidx.annotation.Keep
+import io.hyperswitch.modular_3ds.callbacks.AuthParametersCallback
 import io.hyperswitch.modular_3ds.callbacks.AuthenticationCallback
 import io.hyperswitch.modular_3ds.callbacks.ChallengeCallback
 import io.hyperswitch.modular_3ds.callbacks.InitializationCallback
+import io.hyperswitch.modular_3ds.callbacks.TransactionCallback
 import io.hyperswitch.modular_3ds.models.*
 import io.hyperswitch.modular_3ds.provider.ThreeDSProvider
+import `in`.juspay.trident.core.ConfigParameters
+import `in`.juspay.trident.core.FileHelper
+import `in`.juspay.trident.core.Logger
+import `in`.juspay.trident.core.SdkHelper
 import `in`.juspay.trident.core.ThreeDS2Service
+import `in`.juspay.trident.core.Transaction
+import `in`.juspay.trident.data.AuthenticationRequestParameters
+import `in`.juspay.trident.data.ChallengeParameters as TridentChallengeParameters
+import `in`.juspay.trident.data.ChallengeStatusReceiver
+import `in`.juspay.trident.data.CompletionEvent
+import `in`.juspay.trident.data.ProtocolErrorEvent
+import `in`.juspay.trident.data.RuntimeErrorEvent
+import org.json.JSONObject
 
 /**
  * Trident implementation of ThreeDSProvider using Juspay's Trident SDK.
@@ -20,7 +37,34 @@ class TridentThreeDSProvider : ThreeDSProvider {
     private var isInitialized = false
     private var configuration: ThreeDSConfiguration? = null
     private var threeDS2Service: ThreeDS2Service? = null
+    private var currentTransaction: Transaction? = null
+    private var context: Context? = null
     private val handler = Handler(Looper.getMainLooper())
+    private val transactions = mutableMapOf<String, Transaction>()
+    
+    // SDK Helper implementation
+    private val sdkHelper = object : SdkHelper {
+        override val logger = object : Logger {
+            override fun addLogToPersistedQueue(logLine: JSONObject) {
+                // Log to persistent queue if needed
+            }
+            
+            override fun track(logLine: JSONObject) {
+                // Track logs if needed
+                Log.d("logg",logLine.toString())
+            }
+        }
+        
+        override val fileHelper = object : FileHelper {
+            override fun renewFile(endpoint: String, fileName: String, startTime: Long) {
+                // Renew file if needed
+            }
+            
+            override fun readFromFile(fileName: String): String {
+                return fileName
+            }
+        }
+    }
     
     override fun initialize(
         configuration: ThreeDSConfiguration,
@@ -29,18 +73,15 @@ class TridentThreeDSProvider : ThreeDSProvider {
         this.configuration = configuration
         
         try {
-            // TODO: Initialize Trident SDK with actual configuration
-            // Example initialization (replace with actual Trident SDK calls):
-            // threeDS2Service = ThreeDS2Service.getInstance()
-            // threeDS2Service?.initialize(context, configuration)
+            // Create Trident SDK instance with helper
+            threeDS2Service = ThreeDS2Service.createNewInstance(sdkHelper)
             
-            // Simulate initialization delay
-            handler.postDelayed({
-                isInitialized = true
-                callback.onInitializationSuccess()
-            }, 500)
+            // Mark as initialized only after successful creation
+            isInitialized = true
+            callback.onInitializationSuccess()
             
         } catch (e: Exception) {
+            isInitialized = false
             callback.onInitializationFailure(
                 ThreeDSError(
                     code = "INIT_FAILED",
@@ -52,12 +93,48 @@ class TridentThreeDSProvider : ThreeDSProvider {
         }
     }
     
+    /**
+     * Initialize with context - should be called after basic initialization
+     * This method properly initializes the Trident SDK with the Android context
+     */
+    fun initializeWithContext(context: Context) {
+        this.context = context
+        
+        if (threeDS2Service == null) {
+            throw IllegalStateException("ThreeDS2Service not created. Call initialize() first.")
+        }
+        
+        try {
+            // Set up configuration parameters
+            TridentConfigurator.setConfigParameters()
+            
+            // Initialize Trident SDK with context and proper config parameters
+            threeDS2Service?.initialise(context, TridentConfigurator.configParams, "en-US", null)
+            
+            Log.d("TridentProvider", "Trident SDK initialized with context successfully")
+            
+        } catch (e: Exception) {
+            // Check if it's already initialized - this is acceptable
+            if (e.message?.contains("ThreeDS2Service is already initialized", ignoreCase = true) == true) {
+                Log.d("TridentProvider", "Trident SDK already initialized")
+            } else {
+                Log.e("TridentProvider", "Failed to initialize Trident SDK with context: ${e.message}")
+                throw e
+            }
+        }
+    }
+    
+    /**
+     * Check if the Trident SDK is properly initialized and ready for transactions
+     */
+    private fun isTridentSDKReady(): Boolean {
+        return threeDS2Service != null && context != null && isInitialized
+    }
+    
     override fun isInitialized(): Boolean = isInitialized
     
     override fun getSDKVersion(): String {
-        // TODO: Return actual Trident SDK version
-        // return threeDS2Service?.getSDKVersion() ?: "Unknown"
-        return "Trident-1.0.8-rc.04"
+        return threeDS2Service?.getSDKVersion() ?: "trident-1.0.8-rc.04"
     }
     
     override fun getProviderName(): String = "trident"
@@ -79,48 +156,6 @@ class TridentThreeDSProvider : ThreeDSProvider {
         }
         
         try {
-            // TODO: Implement actual Trident SDK authentication
-            // Example implementation (replace with actual Trident SDK calls):
-            /*
-            val authRequest = createTridentAuthRequest(request)
-            threeDS2Service?.authenticate(authRequest) { result ->
-                when (result.status) {
-                    "Y" -> {
-                        callback.onAuthenticationSuccess(
-                            AuthenticationResponse(
-                                transactionId = request.transactionId,
-                                status = AuthenticationStatus.Y,
-                                authenticationValue = result.authenticationValue,
-                                eci = result.eci,
-                                cavv = result.cavv,
-                                xid = result.xid,
-                                dsTransactionId = result.dsTransactionId,
-                                acsTransactionId = result.acsTransactionId,
-                                threeDSServerTransactionId = result.threeDSServerTransactionId,
-                                messageVersion = request.messageVersion,
-                                challengeRequired = false,
-                                liabilityShift = true,
-                                statusReason = "Authentication successful"
-                            )
-                        )
-                    }
-                    "C" -> {
-                        callback.onChallengeRequired()
-                    }
-                    else -> {
-                        callback.onAuthenticationFailure(
-                            ThreeDSError(
-                                code = "AUTH_FAILED",
-                                message = "Authentication failed",
-                                details = result.errorMessage,
-                                errorType = ErrorType.AUTHENTICATION_ERROR
-                            )
-                        )
-                    }
-                }
-            }
-            */
-            
             // Placeholder implementation - simulate network delay
             handler.postDelayed({
                 // Simulate different scenarios based on card number for testing
@@ -131,17 +166,17 @@ class TridentThreeDSProvider : ThreeDSProvider {
                             AuthenticationResponse(
                                 transactionId = request.transactionId,
                                 status = AuthenticationStatus.Y,
-                                authenticationValue = "trident_auth_value_${System.currentTimeMillis()}",
+                                authenticationValue = "auth_value_${System.currentTimeMillis()}",
                                 eci = "05",
-                                cavv = "trident_cavv_value",
-                                xid = "trident_xid_value",
-                                dsTransactionId = "trident_ds_trans_id",
-                                acsTransactionId = "trident_acs_trans_id",
-                                threeDSServerTransactionId = "trident_3ds_server_trans_id",
+                                cavv = "cavv_value",
+                                xid = "xid_value",
+                                dsTransactionId = "ds_trans_id",
+                                acsTransactionId = "acs_trans_id",
+                                threeDSServerTransactionId = "3ds_server_trans_id",
                                 messageVersion = request.messageVersion,
                                 challengeRequired = false,
                                 liabilityShift = true,
-                                statusReason = "Trident frictionless authentication successful"
+                                statusReason = "Frictionless authentication successful"
                             )
                         )
                     }
@@ -169,17 +204,17 @@ class TridentThreeDSProvider : ThreeDSProvider {
                             AuthenticationResponse(
                                 transactionId = request.transactionId,
                                 status = AuthenticationStatus.A,
-                                authenticationValue = "trident_attempted_auth_value_${System.currentTimeMillis()}",
+                                authenticationValue = "attempted_auth_value_${System.currentTimeMillis()}",
                                 eci = "06",
                                 cavv = null,
-                                xid = "trident_attempted_xid_value",
-                                dsTransactionId = "trident_ds_trans_id",
-                                acsTransactionId = "trident_acs_trans_id",
-                                threeDSServerTransactionId = "trident_3ds_server_trans_id",
+                                xid = "attempted_xid_value",
+                                dsTransactionId = "ds_trans_id",
+                                acsTransactionId = "acs_trans_id",
+                                threeDSServerTransactionId = "3ds_server_trans_id",
                                 messageVersion = request.messageVersion,
                                 challengeRequired = false,
                                 liabilityShift = false,
-                                statusReason = "Trident authentication attempted"
+                                statusReason = "Authentication attempted"
                             )
                         )
                     }
@@ -198,7 +233,168 @@ class TridentThreeDSProvider : ThreeDSProvider {
         }
     }
     
-    override fun handleChallenge(
+    override fun createTransaction(
+        request: TransactionRequest,
+        callback: TransactionCallback
+    ) {
+        if (!isTridentSDKReady()) {
+            val errorMessage = when {
+                !isInitialized -> "Provider not initialized"
+                threeDS2Service == null -> "ThreeDS2Service is null - SDK service not properly initialized"
+                context == null -> "Context not set - Call initializeWithContext() first"
+                else -> "Trident SDK not ready for transactions"
+            }
+            
+            callback.onTransactionFailure(
+                ThreeDSError(
+                    code = "SDK_NOT_READY",
+                    message = errorMessage,
+                    details = "Ensure provider is initialized and context is set before creating transactions",
+                    errorType = ErrorType.PROVIDER_ERROR
+                )
+            )
+            return
+        }
+        
+        try {
+            // Get directory server ID based on card network
+            val directoryServerId = when (request.cardNetwork?.uppercase()) {
+                "VISA" -> ThreeDS2Service.getDirectoryServerId("VISA")
+                "MASTERCARD", "MC" -> ThreeDS2Service.getDirectoryServerId("MASTERCARD")
+                "AMEX", "AMERICAN_EXPRESS" -> ThreeDS2Service.getDirectoryServerId("AMEX")
+                else -> ThreeDS2Service.getDirectoryServerId("VISA") // Default to VISA
+            }
+            
+            Log.d("TridentProvider", "Creating transaction with directory server ID: $directoryServerId, message version: ${request.messageVersion}")
+            
+            // Create transaction using Trident SDK with callback
+            threeDS2Service?.createTransaction(
+                directoryServerID = directoryServerId,
+                messageVersion = request.messageVersion,
+                onTransaction = { sdkTransaction ->
+                    Log.d("TridentProvider", "Transaction created successfully")
+                    currentTransaction = sdkTransaction
+                    
+                    // Store transaction for later retrieval
+                    val transactionId = "txn_${System.currentTimeMillis()}"
+                    transactions[transactionId] = sdkTransaction
+                    
+                    // Get authentication request parameters immediately
+                    val aReq = sdkTransaction.getAuthenticationRequestParameters()
+                    
+                    if (aReq != null) {
+                        Log.d("TridentProvider", "Authentication request parameters obtained successfully")
+                        callback.onTransactionSuccess(
+                            TransactionResponse(
+                                transactionId = transactionId,
+                                sdkTransactionId = aReq.sdkTransactionID,
+                                serverTransactionId = aReq.sdkTransactionID, // Use SDK transaction ID as server transaction ID
+                                acsTransactionId = null,
+                                dsTransactionId = null,
+                                messageVersion = request.messageVersion,
+                                deviceData = aReq.deviceData,
+                                sdkAppId = aReq.sdkAppID,
+                                sdkEncryptionData = "", // Not available in Trident SDK
+                                sdkEphemeralPublicKey = aReq.sdkEphemeralPublicKey ?: "",
+                                sdkReferenceNumber = aReq.sdkReferenceNumber
+                            )
+                        )
+                    } else {
+                        Log.e("TridentProvider", "Authentication request parameters were null")
+                        callback.onTransactionFailure(
+                            ThreeDSError(
+                                code = "TRANSACTION_FAILED",
+                                message = "Failed to get authentication parameters",
+                                details = "Authentication request parameters were null",
+                                errorType = ErrorType.PROVIDER_ERROR
+                            )
+                        )
+                    }
+                }
+            )
+            
+        } catch (e: Exception) {
+            Log.e("TridentProvider", "Exception in createTransaction: ${e.message}", e)
+            callback.onTransactionFailure(
+                ThreeDSError(
+                    code = "TRANSACTION_ERROR",
+                    message = "Transaction creation error: ${e.message}",
+                    details = e.toString(),
+                    errorType = ErrorType.PROVIDER_ERROR
+                )
+            )
+        }
+    }
+    
+    override fun getAuthenticationRequestParameters(
+        transactionId: String,
+        callback: AuthParametersCallback
+    ) {
+        if (!isInitialized) {
+            callback.onAuthParametersFailure(
+                ThreeDSError(
+                    code = "NOT_INITIALIZED",
+                    message = "Provider not initialized",
+                    details = null,
+                    errorType = ErrorType.PROVIDER_ERROR
+                )
+            )
+            return
+        }
+        
+        try {
+            // Get the transaction by ID from our stored transactions
+            val transaction = transactions[transactionId] ?: currentTransaction
+            
+            if (transaction != null) {
+                val result = transaction.getAuthenticationRequestParameters()
+                if (result != null) {
+                    callback.onAuthParametersSuccess(
+                        AuthenticationParameters(
+                            deviceData = result.deviceData,
+                            sdkTransactionId = result.sdkTransactionID,
+                            sdkAppId = result.sdkAppID,
+                            sdkEncryptionData = "", // Not available in Trident SDK
+                            sdkEphemeralPublicKey = result.sdkEphemeralPublicKey ?: "",
+                            sdkReferenceNumber = result.sdkReferenceNumber,
+                            messageVersion = result.messageVersion,
+                            threeDSCompInd = "Y"
+                        )
+                    )
+                } else {
+                    callback.onAuthParametersFailure(
+                        ThreeDSError(
+                            code = "AUTH_PARAMS_FAILED",
+                            message = "Failed to get authentication parameters",
+                            details = "Trident SDK returned null parameters",
+                            errorType = ErrorType.PROVIDER_ERROR
+                        )
+                    )
+                }
+            } else {
+                callback.onAuthParametersFailure(
+                    ThreeDSError(
+                        code = "TRANSACTION_NOT_FOUND",
+                        message = "Transaction not found",
+                        details = "No transaction found with ID: $transactionId",
+                        errorType = ErrorType.PROVIDER_ERROR
+                    )
+                )
+            }
+            
+        } catch (e: Exception) {
+            callback.onAuthParametersFailure(
+                ThreeDSError(
+                    code = "AUTH_PARAMS_ERROR",
+                    message = "Authentication parameters error: ${e.message}",
+                    details = e.toString(),
+                    errorType = ErrorType.PROVIDER_ERROR
+                )
+            )
+        }
+    }
+    
+    override fun doChallenge(
         parameters: ChallengeParameters,
         callback: ChallengeCallback
     ) {
@@ -215,47 +411,101 @@ class TridentThreeDSProvider : ThreeDSProvider {
         }
         
         try {
-            // TODO: Implement actual Trident SDK challenge handling
-            // Example implementation (replace with actual Trident SDK calls):
-            /*
-            val challengeParams = createTridentChallengeParams(parameters)
-            threeDS2Service?.handleChallenge(challengeParams) { result ->
-                when (result.status) {
-                    "Y" -> {
+            // Use current transaction for challenge
+            val transaction = currentTransaction
+            
+            if (transaction != null) {
+                // Create Trident challenge parameters using the correct constructor
+                val tridentChallengeParams = TridentChallengeParameters(
+                    threeDSServerTransactionID = parameters.threeDSServerTransactionId ?: "",
+                    acsTransactionID = parameters.acsTransactionId ?: "",
+                    acsRefNumber = parameters.acsReferenceNumber ?: "",
+                    acsSignedContent = parameters.acsSignedContent ?: "",
+                    threeDSRequestorAppURL = parameters.threeDSRequestorAppURL
+                )
+                
+                // Create challenge status receiver
+                val challengeStatusReceiver = object : ChallengeStatusReceiver {
+                    override fun completed(completionEvent: CompletionEvent) {
                         callback.onChallengeSuccess(
                             ChallengeResult(
-                                transactionId = parameters.threeDSServerTransactionId,
+                                transactionId = completionEvent.sdkTransactionId ?: "",
                                 status = AuthenticationStatus.Y,
-                                authenticationValue = result.authenticationValue,
-                                eci = result.eci
+                                authenticationValue = completionEvent.transactionStatus ?: "",
+                                eci = completionEvent.transactionStatus ?: ""
                             )
                         )
                     }
-                    else -> {
+                    
+                    override fun cancelled() {
+                        callback.onChallengeCancelled()
+                    }
+                    
+                    override fun timedout() {
+                        callback.onChallengeFailure(
+                            ThreeDSError(
+                                code = "CHALLENGE_TIMEOUT",
+                                message = "Challenge timed out",
+                                details = "Challenge flow timed out",
+                                errorType = ErrorType.CHALLENGE_ERROR
+                            )
+                        )
+                    }
+                    
+                    override fun protocolError(protocolErrorEvent: ProtocolErrorEvent) {
                         callback.onChallengeFailure(
                             ThreeDSError(
-                                code = "CHALLENGE_FAILED",
-                                message = "Challenge failed",
-                                details = result.errorMessage,
+                                code = "PROTOCOL_ERROR",
+                                message = "Protocol error during challenge",
+                                details = protocolErrorEvent.errorMessage?.errorDescription ?: "Unknown protocol error",
+                                errorType = ErrorType.CHALLENGE_ERROR
+                            )
+                        )
+                    }
+                    
+                    override fun runtimeError(runtimeErrorEvent: RuntimeErrorEvent) {
+                        callback.onChallengeFailure(
+                            ThreeDSError(
+                                code = "RUNTIME_ERROR",
+                                message = "Runtime error during challenge",
+                                details = runtimeErrorEvent.errorMessage ?: "Unknown runtime error",
                                 errorType = ErrorType.CHALLENGE_ERROR
                             )
                         )
                     }
                 }
-            }
-            */
-            
-            // Placeholder implementation - simulate challenge completion
-            handler.postDelayed({
-                callback.onChallengeSuccess(
-                    ChallengeResult(
-                        transactionId = parameters.threeDSServerTransactionId,
-                        status = AuthenticationStatus.Y,
-                        authenticationValue = "trident_challenge_result_${System.currentTimeMillis()}",
-                        eci = "05"
+                
+                // Perform challenge - need activity context
+                val activity = context as? Activity
+                if (activity != null) {
+                    transaction.doChallenge(
+                        activity,
+                        tridentChallengeParams,
+                        challengeStatusReceiver,
+                        5, // timeOutInMinutes
+                        "{}" // bankDetails
+                    )
+                } else {
+                    callback.onChallengeFailure(
+                        ThreeDSError(
+                            code = "NO_ACTIVITY",
+                            message = "Activity context required for challenge",
+                            details = "Challenge requires an Activity context",
+                            errorType = ErrorType.PROVIDER_ERROR
+                        )
+                    )
+                }
+                
+            } else {
+                callback.onChallengeFailure(
+                    ThreeDSError(
+                        code = "TRANSACTION_NOT_FOUND",
+                        message = "Transaction not found for challenge",
+                        details = "No current transaction available",
+                        errorType = ErrorType.PROVIDER_ERROR
                     )
                 )
-            }, 3000)
+            }
             
         } catch (e: Exception) {
             callback.onChallengeFailure(
@@ -269,11 +519,20 @@ class TridentThreeDSProvider : ThreeDSProvider {
         }
     }
     
+    override fun handleChallenge(
+        parameters: ChallengeParameters,
+        callback: ChallengeCallback
+    ) {
+        doChallenge(parameters, callback)
+    }
+    
     override fun cleanup() {
         try {
-            // TODO: Cleanup Trident SDK resources
-            // threeDS2Service?.cleanup()
+            // Cleanup Trident SDK resources
+            transactions.clear()
+            currentTransaction = null
             threeDS2Service = null
+            context = null
             isInitialized = false
             configuration = null
         } catch (e: Exception) {
@@ -282,19 +541,6 @@ class TridentThreeDSProvider : ThreeDSProvider {
     }
     
     override fun supportsConfiguration(configuration: ThreeDSConfiguration): Boolean {
-        // TODO: Check if Trident SDK supports the given configuration
-        // For now, assume it supports all configurations
         return true
     }
-    
-    // TODO: Add helper methods for converting between our models and Trident SDK models
-    /*
-    private fun createTridentAuthRequest(request: AuthenticationRequest): TridentAuthRequest {
-        // Convert our AuthenticationRequest to Trident's format
-    }
-    
-    private fun createTridentChallengeParams(parameters: ChallengeParameters): TridentChallengeParams {
-        // Convert our ChallengeParameters to Trident's format
-    }
-    */
 }