Updated on 2026-08-14

2025-01-16 10:07:05 +03:00 · 2025-01-16 10:07:05 +03:00 · ea087aac49
commit ea087aac49
parent bfd38fd000
21 changed files with 464 additions and 8 deletions
--- a/app/src/main/java/com/tangem/tap/data/DefaultVisaOTPStorage.kt
+++ b/app/src/main/java/com/tangem/tap/data/DefaultVisaOTPStorage.kt
@ -0,0 +1,42 @@
+package com.tangem.tap.data
+
+import android.content.Context
+import com.tangem.common.services.secure.SecureStorage
+import com.tangem.datasource.local.visa.VisaOTPStorage
+import com.tangem.sdk.storage.AndroidSecureStorage
+import com.tangem.sdk.storage.createEncryptedSharedPreferences
+import com.tangem.utils.coroutines.CoroutineDispatcherProvider
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.withContext
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class DefaultVisaOTPStorage @Inject constructor(
+    @ApplicationContext applicationContext: Context,
+    private val dispatcherProvider: CoroutineDispatcherProvider,
+) : VisaOTPStorage {
+
+    private val secureStorage = AndroidSecureStorage(
+        preferences = SecureStorage.createEncryptedSharedPreferences(
+            context = applicationContext,
+            storageName = "visa_otp_storage",
+        ),
+    )
+
+    override suspend fun saveOTP(cardId: String, otp: ByteArray) = withContext(dispatcherProvider.io) {
+        secureStorage.store(otp, VISA_OTP_KEY_PREFIX + cardId)
+    }
+
+    override suspend fun getOTP(cardId: String): ByteArray? = withContext(dispatcherProvider.io) {
+        secureStorage.get(VISA_OTP_KEY_PREFIX + cardId)
+    }
+
+    override suspend fun removeOTP(cardId: String) = withContext(dispatcherProvider.io) {
+        secureStorage.delete(VISA_OTP_KEY_PREFIX + cardId)
+    }
+
+    private companion object {
+        const val VISA_OTP_KEY_PREFIX = "visa_otp_"
+    }
+}
--- a/app/src/main/java/com/tangem/tap/di/TangemSdkManagerModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/TangemSdkManagerModule.kt
@ -6,6 +6,7 @@ import com.tangem.domain.card.repository.CardSdkConfigRepository
 import com.tangem.sdk.api.TangemSdkManager
 import com.tangem.tap.domain.sdk.impl.DefaultTangemSdkManager
 import com.tangem.tap.domain.sdk.impl.MockTangemSdkManager
+import com.tangem.tap.domain.tasks.visa.VisaCardActivationTask
 import com.tangem.tap.domain.visa.VisaCardScanHandler
 import dagger.Module
 import dagger.Provides
@ -24,6 +25,7 @@ internal class TangemSdkManagerModule {
        @ApplicationContext context: Context,
        cardSdkConfigRepository: CardSdkConfigRepository,
        visaCardScanHandler: VisaCardScanHandler,
+        visaCardActivationTaskFactory: VisaCardActivationTask.Factory,
    ): TangemSdkManager {
        return if (BuildConfig.MOCK_DATA_SOURCE) {
            MockTangemSdkManager(resources = context.resources)
@ -32,6 +34,7 @@ internal class TangemSdkManagerModule {
                cardSdkConfigRepository = cardSdkConfigRepository,
                resources = context.resources,
                visaCardScanHandler = visaCardScanHandler,
+                visaCardActivationTaskFactory = visaCardActivationTaskFactory,
            )
        }
    }
--- a/app/src/main/java/com/tangem/tap/di/data/VisaStorageModule.kt
+++ b/app/src/main/java/com/tangem/tap/di/data/VisaStorageModule.kt
@ -1,7 +1,9 @@
 package com.tangem.tap.di.data

 import com.tangem.datasource.local.visa.VisaAuthTokenStorage
+import com.tangem.datasource.local.visa.VisaOTPStorage
 import com.tangem.tap.data.DefaultVisaAuthTokenStorage
+import com.tangem.tap.data.DefaultVisaOTPStorage
 import dagger.Binds
 import dagger.Module
 import dagger.hilt.InstallIn
@ -15,4 +17,8 @@ internal interface VisaStorageModule {
    @Binds
    @Singleton
    fun bindVisaStorage(impl: DefaultVisaAuthTokenStorage): VisaAuthTokenStorage
+
+    @Binds
+    @Singleton
+    fun bindVisaOTPStorage(impl: DefaultVisaOTPStorage): VisaOTPStorage
 }
--- a/app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/sdk/impl/DefaultTangemSdkManager.kt
@ -24,6 +24,9 @@ import com.tangem.domain.common.util.cardTypesResolver
 import com.tangem.domain.common.util.derivationStyleProvider
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.visa.model.VisaActivationInput
+import com.tangem.domain.visa.model.VisaAuthChallenge
+import com.tangem.domain.visa.model.VisaCardActivationResponse
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.operations.ScanTask
 import com.tangem.operations.derivation.DerivationTaskResponse
@ -40,6 +43,7 @@ import com.tangem.tap.domain.tasks.product.CreateProductWalletTask
 import com.tangem.tap.domain.tasks.product.ResetBackupCardTask
 import com.tangem.tap.domain.tasks.product.ResetToFactorySettingsTask
 import com.tangem.tap.domain.tasks.product.ScanProductTask
+import com.tangem.tap.domain.tasks.visa.VisaCardActivationTask
 import com.tangem.tap.domain.twins.CreateFirstTwinWalletTask
 import com.tangem.tap.domain.twins.CreateSecondTwinWalletTask
 import com.tangem.tap.domain.twins.FinalizeTwinTask
@ -55,6 +59,7 @@ internal class DefaultTangemSdkManager(
    private val cardSdkConfigRepository: CardSdkConfigRepository,
    private val resources: Resources,
    private val visaCardScanHandler: VisaCardScanHandler,
+    private val visaCardActivationTaskFactory: VisaCardActivationTask.Factory,
 ) : TangemSdkManager {

    private val awaitInitializationMutex = Mutex()
@ -466,6 +471,28 @@ internal class DefaultTangemSdkManager(

    // endregion

+    // region Visa-specific
+
+    override suspend fun activateVisaCard(
+        accessCode: String,
+        challengeToSign: VisaAuthChallenge.Card?,
+        activationInput: VisaActivationInput,
+    ): CompletionResult<VisaCardActivationResponse> {
+        return coroutineScope {
+            runTaskAsyncReturnOnMain(
+                runnable = visaCardActivationTaskFactory.create(
+                    accessCode = accessCode,
+                    challengeToSign = challengeToSign,
+                    activationInput = activationInput,
+                    coroutineScope = this,
+                ),
+                initialMessage = Message(resources.getStringSafe(R.string.initial_message_tap_header)),
+            )
+        }
+    }
+
+    // endregion
+
    companion object {
        private const val MAX_INITIALIZE_ATTEMPTS = 10
    }
--- a/app/src/main/java/com/tangem/tap/domain/sdk/impl/MockTangemSdkManager.kt
+++ b/app/src/main/java/com/tangem/tap/domain/sdk/impl/MockTangemSdkManager.kt
@ -17,6 +17,9 @@ import com.tangem.crypto.hdWallet.DerivationPath
 import com.tangem.crypto.hdWallet.bip32.ExtendedPublicKey
 import com.tangem.domain.models.scan.CardDTO
 import com.tangem.domain.models.scan.ScanResponse
+import com.tangem.domain.visa.model.VisaActivationInput
+import com.tangem.domain.visa.model.VisaAuthChallenge
+import com.tangem.domain.visa.model.VisaCardActivationResponse
 import com.tangem.domain.wallets.models.UserWalletId
 import com.tangem.operations.derivation.DerivationTaskResponse
 import com.tangem.operations.preflightread.PreflightReadFilter
@ -194,4 +197,14 @@ class MockTangemSdkManager(
    }

    // endregion
+
+    // region Visa-specific
+
+    override suspend fun activateVisaCard(
+        accessCode: String,
+        challengeToSign: VisaAuthChallenge.Card?,
+        activationInput: VisaActivationInput,
+    ): CompletionResult<VisaCardActivationResponse> {
+        error("Not implemented")
+    }
 }
--- a/app/src/main/java/com/tangem/tap/domain/tasks/visa/VisaCardActivationTask.kt
+++ b/app/src/main/java/com/tangem/tap/domain/tasks/visa/VisaCardActivationTask.kt
@ -0,0 +1,268 @@
+package com.tangem.tap.domain.tasks.visa
+
+import com.reown.util.hexToBytes
+import com.tangem.common.CompletionResult
+import com.tangem.common.core.CardSession
+import com.tangem.common.core.CardSessionRunnable
+import com.tangem.common.core.CompletionCallback
+import com.tangem.common.core.TangemSdkError
+import com.tangem.common.extensions.toHexString
+import com.tangem.common.map
+import com.tangem.datasource.local.visa.VisaAuthTokenStorage
+import com.tangem.datasource.local.visa.VisaOTPStorage
+import com.tangem.domain.common.visa.VisaUtilities
+import com.tangem.domain.visa.model.*
+import com.tangem.domain.visa.repository.VisaActivationRepository
+import com.tangem.domain.visa.repository.VisaAuthRepository
+import com.tangem.operations.GenerateOTPCommand
+import com.tangem.operations.attestation.AttestCardKeyCommand
+import com.tangem.operations.pins.SetUserCodeCommand
+import com.tangem.operations.sign.SignHashCommand
+import com.tangem.operations.sign.SignHashResponse
+import com.tangem.operations.wallet.CreateWalletTask
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedFactory
+import dagger.assisted.AssistedInject
+import kotlinx.coroutines.*
+import kotlin.coroutines.resume
+import kotlin.jvm.Throws
+
+@Suppress("LongParameterList")
+class VisaCardActivationTask @AssistedInject constructor(
+    @Assisted private val accessCode: String,
+    @Assisted private val challengeToSign: VisaAuthChallenge.Card?,
+    @Assisted private val activationInput: VisaActivationInput,
+    @Assisted private val coroutineScope: CoroutineScope,
+    private val otpStorage: VisaOTPStorage,
+    private val visaAuthTokenStorage: VisaAuthTokenStorage,
+    private val visaAuthRepository: VisaAuthRepository,
+    private val visaActivationRepository: VisaActivationRepository,
+) : CardSessionRunnable<VisaCardActivationResponse> {
+
+    override fun run(session: CardSession, callback: CompletionCallback<VisaCardActivationResponse>) {
+        coroutineScope.launch {
+            callback(runSuspend(session))
+        }
+    }
+
+    private suspend fun runSuspend(session: CardSession): CompletionResult<VisaCardActivationResponse> {
+        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+
+        if (card.cardId != activationInput.cardId) {
+            return CompletionResult.Failure(TangemSdkError.Underlying(VisaActivationError.WrongCard.message))
+        }
+
+        return if (challengeToSign != null) {
+            signAuthorizationChallenge(session, challengeToSign)
+        } else {
+            val activationOrder = runCatching { visaActivationRepository.getActivationOrderToSign() }
+                .getOrElse {
+                    return CompletionResult.Failure(TangemSdkError.Underlying(it.message ?: ""))
+                }
+
+            signOrder(session, activationOrder)
+        }
+    }
+
+    private suspend fun signAuthorizationChallenge(
+        session: CardSession,
+        challengeToSign: VisaAuthChallenge.Card,
+    ): CompletionResult<VisaCardActivationResponse> {
+        val attestationCommand = AttestCardKeyCommand(challenge = challengeToSign.challenge.hexToBytes())
+        val result = suspendCancellableCoroutine { continuation ->
+            attestationCommand.run(session = session) { attestationResponse ->
+                continuation.resume(attestationResponse)
+            }
+        }
+
+        return when (result) {
+            is CompletionResult.Success -> {
+                processSignedAuthorizationChallenge(
+                    session = session,
+                    signedChallenge = challengeToSign.toSignedChallenge(
+                        signedChallenge = result.data.cardSignature.toHexString(),
+                        salt = result.data.salt.toHexString(),
+                    ),
+                )
+            }
+            is CompletionResult.Failure -> {
+                CompletionResult.Failure(result.error)
+            }
+        }
+    }
+
+    private suspend fun processSignedAuthorizationChallenge(
+        session: CardSession,
+        signedChallenge: VisaAuthSignedChallenge,
+    ): CompletionResult<VisaCardActivationResponse> {
+        return coroutineScope {
+            val activationOrderDeferred = async { getActivationOrderToSign(signedChallenge) }
+            val otpTaskDeferred = async { createWallet(session) }
+
+            val order = runCatching { activationOrderDeferred.await() }
+                .getOrElse {
+                    otpTaskDeferred.cancel()
+                    return@coroutineScope CompletionResult.Failure(TangemSdkError.Underlying(it.message ?: ""))
+                }
+
+            otpTaskDeferred.await()
+
+            signOrder(session, order)
+        }
+    }
+
+    @Throws(TangemSdkError::class)
+    private suspend fun getActivationOrderToSign(signedChallenge: VisaAuthSignedChallenge): ActivationOrder {
+        val tokens = runCatching {
+            visaAuthRepository.getAccessTokens(signedChallenge)
+        }.getOrElse {
+            throw TangemSdkError.Underlying(
+                "Underlying network error:  ${it.message ?: ""}",
+            )
+        }
+
+        visaAuthTokenStorage.store(tokens)
+
+        return visaActivationRepository.getActivationOrderToSign()
+    }
+
+    private suspend fun createWallet(session: CardSession): CompletionResult<Unit> {
+        coroutineScope { ensureActive() }
+
+        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+
+        return if (card.wallets.any { it.curve == VisaUtilities.mandatoryCurve }) {
+            createOTP(session)
+        } else {
+            val createWalletTask = CreateWalletTask(VisaUtilities.mandatoryCurve)
+            val result = suspendCancellableCoroutine { continuation ->
+                createWalletTask.run(session) { createWalletResult ->
+                    continuation.resume(createWalletResult)
+                }
+            }
+
+            when (result) {
+                is CompletionResult.Success -> {
+                    createOTP(session)
+                }
+                is CompletionResult.Failure -> {
+                    CompletionResult.Failure(result.error)
+                }
+            }
+        }
+    }
+
+    private suspend fun createOTP(session: CardSession): CompletionResult<Unit> {
+        coroutineScope { ensureActive() }
+
+        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+
+        val otp = otpStorage.getOTP(card.cardId)
+        return if (otp != null) {
+            CompletionResult.Success(Unit)
+        } else {
+            val otpCommand = GenerateOTPCommand()
+            val result = suspendCancellableCoroutine { continuation ->
+                otpCommand.run(session) { otpResult ->
+                    continuation.resume(otpResult)
+                }
+            }
+
+            when (result) {
+                is CompletionResult.Success -> {
+                    otpStorage.saveOTP(card.cardId, result.data.rootOTP)
+                    CompletionResult.Success(Unit)
+                }
+                is CompletionResult.Failure -> {
+                    CompletionResult.Failure(result.error)
+                }
+            }
+        }
+    }
+
+    private suspend fun signOrder(
+        session: CardSession,
+        order: ActivationOrder,
+    ): CompletionResult<VisaCardActivationResponse> {
+        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+        val wallet =
+            card.wallets.firstOrNull() ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+        val task = SignHashCommand(order.hash.hexToBytes(), wallet.publicKey)
+        val result = suspendCancellableCoroutine { continuation ->
+            task.run(session) { signResult ->
+                continuation.resume(signResult)
+            }
+        }
+
+        return when (result) {
+            is CompletionResult.Success -> {
+                handleSignedOrder(
+                    session = session,
+                    activationOrder = order,
+                    response = result.data,
+                )
+            }
+            is CompletionResult.Failure -> {
+                CompletionResult.Failure(result.error)
+            }
+        }
+    }
+
+    private suspend fun handleSignedOrder(
+        session: CardSession,
+        activationOrder: ActivationOrder,
+        response: SignHashResponse,
+    ): CompletionResult<VisaCardActivationResponse> {
+        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+
+        val signedOrder = SignedActivationOrder(
+            activationOrder = activationOrder,
+            signature = response.signature.toHexString(),
+        )
+
+        val otp = otpStorage.getOTP(card.cardId) ?: return CompletionResult.Failure(
+            TangemSdkError.Underlying(VisaActivationError.MissingRootOTP.message),
+        )
+
+        val activationResponse = VisaCardActivationResponse(
+            signedActivationOrder = signedOrder,
+            rootOTP = VisaRootOTP(otp.toHexString()),
+        )
+
+        return setupAccessCode(session).map { activationResponse }
+    }
+
+    private suspend fun setupAccessCode(session: CardSession): CompletionResult<Unit> {
+        val card = session.environment.card ?: return CompletionResult.Failure(TangemSdkError.MissingPreflightRead())
+
+        if (card.isAccessCodeSet) {
+            return CompletionResult.Success(Unit)
+        }
+
+        val task = SetUserCodeCommand.changeAccessCode(accessCode)
+        val result = suspendCancellableCoroutine { continuation ->
+            task.run(session) { setAccessCodeResult ->
+                continuation.resume(setAccessCodeResult)
+            }
+        }
+
+        return when (result) {
+            is CompletionResult.Success -> {
+                CompletionResult.Success(Unit)
+            }
+            is CompletionResult.Failure -> {
+                CompletionResult.Failure(result.error)
+            }
+        }
+    }
+
+    @AssistedFactory
+    interface Factory {
+        fun create(
+            accessCode: String,
+            challengeToSign: VisaAuthChallenge.Card?,
+            activationInput: VisaActivationInput,
+            coroutineScope: CoroutineScope,
+        ): VisaCardActivationTask
+    }
+}
--- a/app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt
+++ b/app/src/main/java/com/tangem/tap/domain/userWalletList/di/UserWalletsListManagerModule.kt
@ -61,7 +61,7 @@ internal object UserWalletsListManagerModule {
            .add(TangemSdkAdapter.DateAdapter())
            .add(TangemSdkAdapter.DerivationNodeAdapter())
            .add(TangemSdkAdapter.FirmwareVersionAdapter()) // For PrimaryCard model
-            .add(VisaCardActivationStatus.serializer)
+            .add(VisaCardActivationStatus.jsonAdapter)
            .add(KotlinJsonAdapterFactory())
            .build()