Merge pull request #99 from radixdlt/feature/ABW-778

Cap 21 changes & Persona login flow

app/build.gradle

@@ -46,6 +46,7 @@ android {
         versionName "0.0.1"
         buildConfigField "boolean", "DEBUG_MODE", "true"
         buildConfigField "String", "GATEWAY_API_URL", '"https://betanet.radixdlt.com"'
+        buildConfigField "String", "WELL_KNOWN_URL_SUFFIX", '".well-known/radix.json"'
         resValue "string", "app_name", "Radix Wallet"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         vectorDrawables {
@@ -195,6 +196,7 @@ dependencies {
     testImplementation libs.coroutinesTest
     testImplementation libs.mockitoKotlin
     testImplementation libs.mockitoInline
+    testImplementation libs.turbine
 
     androidTestImplementation libs.androidXJunit
     androidTestImplementation libs.espresso

app/src/main/java/com/babylon/wallet/android/MainViewModel.kt

@@ -10,6 +10,7 @@ import com.babylon.wallet.android.domain.common.OneOffEventHandler
 import com.babylon.wallet.android.domain.common.OneOffEventHandlerImpl
 import com.babylon.wallet.android.domain.model.MessageFromDataChannel.ConnectionStateChanged
 import com.babylon.wallet.android.domain.model.MessageFromDataChannel.IncomingRequest
+import com.babylon.wallet.android.domain.usecases.AuthorizeSpecifiedPersonaUseCase
 import com.babylon.wallet.android.utils.parseEncryptionKeyFromConnectionPassword
 import dagger.hilt.android.lifecycle.HiltViewModel
 import kotlinx.coroutines.Job
@@ -34,6 +35,7 @@ class MainViewModel @Inject constructor(
     profileDataSource: ProfileDataSource,
     private val peerdroidClient: PeerdroidClient,
     private val incomingRequestRepository: IncomingRequestRepository,
+    private val authorizeSpecifiedPersonaUseCase: AuthorizeSpecifiedPersonaUseCase
 ) : ViewModel(), OneOffEventHandler<MainEvent> by OneOffEventHandlerImpl() {
 
     val state = combine(
@@ -111,13 +113,35 @@ class MainViewModel @Inject constructor(
                         if (message == ConnectionStateChanged.CLOSING || message == ConnectionStateChanged.CLOSE) {
                             restartConnectionToDapp()
                         }
-                    } else if (message is IncomingRequest && message != IncomingRequest.None) {
-                        incomingRequestRepository.add(message)
+                    } else if (message is IncomingRequest) {
+                        handleIncomingRequest(message)
                     }
                 }
         }
     }
 
+    private fun handleIncomingRequest(request: IncomingRequest) {
+        viewModelScope.launch {
+//            val result = dappMetadataRepository.verifyDappSimple(
+//                origin = request.metadata.origin,
+//                dAppDefinitionAddress = request.metadata.dAppDefinitionAddress
+//            )
+//            if (result is com.babylon.wallet.android.domain.common.Result.Success && result.data) {
+
+            when (val result = authorizeSpecifiedPersonaUseCase(request)) {
+                is com.babylon.wallet.android.domain.common.Result.Error -> {
+                    incomingRequestRepository.add(request)
+                }
+                is com.babylon.wallet.android.domain.common.Result.Success -> {
+                    sendEvent(MainEvent.HandledUsePersonaAuthRequest(result.data))
+                }
+            }
+//            } else {
+//                 TODO dApp verification failed
+//            }
+        }
+    }
+
     private fun restartConnectionToDapp() {
         viewModelScope.launch {
             incomingRequestsJob?.cancel()
@@ -144,6 +168,7 @@ class MainViewModel @Inject constructor(
 
 sealed class MainEvent : OneOffEvent {
     data class IncomingRequestEvent(val request: IncomingRequest) : MainEvent()
+    data class HandledUsePersonaAuthRequest(val dAppName: String) : MainEvent()
 }
 
 data class MainUiState(

app/src/main/java/com/babylon/wallet/android/WalletApp.kt

@@ -5,14 +5,15 @@ import androidx.compose.runtime.Composable
 import androidx.compose.runtime.LaunchedEffect
 import com.babylon.wallet.android.domain.model.MessageFromDataChannel
 import com.babylon.wallet.android.presentation.createaccount.ROUTE_CREATE_ACCOUNT
-import com.babylon.wallet.android.presentation.dapp.account.chooseAccountsScreen
+import com.babylon.wallet.android.presentation.dapp.accountonetime.chooseAccountsOneTime
+import com.babylon.wallet.android.presentation.dapp.requestsuccess.requestSuccess
 import com.babylon.wallet.android.presentation.navigation.NavigationHost
 import com.babylon.wallet.android.presentation.navigation.Screen
+import com.babylon.wallet.android.presentation.navigation.dapp.dappLogin
 import com.babylon.wallet.android.presentation.transaction.transactionApproval
 import com.google.accompanist.navigation.animation.rememberAnimatedNavController
 import com.google.accompanist.pager.ExperimentalPagerApi
 import kotlinx.coroutines.flow.Flow
-import timber.log.Timber
 
 @ExperimentalPagerApi
 @OptIn(ExperimentalAnimationApi::class)
@@ -48,20 +49,22 @@ fun WalletApp(
             when (event) {
                 is MainEvent.IncomingRequestEvent -> {
                     when (val incomingRequest = event.request) {
-                        is MessageFromDataChannel.IncomingRequest.AccountsRequest -> {
-                            navController.chooseAccountsScreen(requestId = incomingRequest.requestId)
-                        }
-                        MessageFromDataChannel.IncomingRequest.None -> {
+                        is MessageFromDataChannel.IncomingRequest.TransactionRequest -> {
+                            navController.transactionApproval(incomingRequest.requestId)
                         }
-                        MessageFromDataChannel.IncomingRequest.ParsingError -> {
-                            Timber.d("Failed to parse incoming request")
+                        is MessageFromDataChannel.IncomingRequest.AuthorizedRequest -> {
+                            navController.dappLogin(incomingRequest.requestId)
                         }
-                        is MessageFromDataChannel.IncomingRequest.TransactionWriteRequest -> {
-                            navController.transactionApproval(incomingRequest.requestId)
+                        is MessageFromDataChannel.IncomingRequest.UnauthorizedRequest -> {
+                            if (incomingRequest.oneTimeAccountsRequestItem != null) {
+                                navController.chooseAccountsOneTime(incomingRequest.requestId)
+                            }
                         }
-                        MessageFromDataChannel.IncomingRequest.Unknown -> {}
                     }
                 }
+                is MainEvent.HandledUsePersonaAuthRequest -> {
+                    navController.requestSuccess(event.dAppName)
+                }
             }
         }
     }

app/src/main/java/com/babylon/wallet/android/data/dapp/DAppMessenger.kt

@@ -1,16 +1,24 @@
 package com.babylon.wallet.android.data.dapp
 
-import com.babylon.wallet.android.data.dapp.model.OneTimeAccountsRequestType
-import com.babylon.wallet.android.data.dapp.model.OneTimeAccountsWithoutProofOfOwnershipResponseItem
+import com.babylon.wallet.android.data.dapp.model.AccountDto
+import com.babylon.wallet.android.data.dapp.model.AuthLoginWithoutChallengeRequestResponseItem
+import com.babylon.wallet.android.data.dapp.model.OneTimeAccountsWithoutProofOfOwnershipRequestResponseItem
+import com.babylon.wallet.android.data.dapp.model.OngoingAccountsWithoutProofOfOwnershipRequestResponseItem
+import com.babylon.wallet.android.data.dapp.model.PersonaDto
 import com.babylon.wallet.android.data.dapp.model.SendTransactionResponseItem
-import com.babylon.wallet.android.data.dapp.model.WalletErrorResponse
+import com.babylon.wallet.android.data.dapp.model.WalletAuthorizedRequestResponseItems
 import com.babylon.wallet.android.data.dapp.model.WalletErrorType
-import com.babylon.wallet.android.data.dapp.model.WalletResponse
+import com.babylon.wallet.android.data.dapp.model.WalletInteractionFailureResponse
+import com.babylon.wallet.android.data.dapp.model.WalletInteractionResponse
+import com.babylon.wallet.android.data.dapp.model.WalletInteractionSuccessResponse
+import com.babylon.wallet.android.data.dapp.model.WalletTransactionResponseItems
+import com.babylon.wallet.android.data.dapp.model.WalletUnauthorizedRequestResponseItems
 import com.babylon.wallet.android.data.dapp.model.toDataModel
 import com.babylon.wallet.android.domain.common.Result
 import com.babylon.wallet.android.presentation.dapp.account.AccountItemUiModel
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import rdx.works.profile.data.model.pernetwork.OnNetwork
 import timber.log.Timber
 import javax.inject.Inject
 
@@ -27,7 +35,7 @@ interface DAppMessenger {
         accounts: List<AccountItemUiModel>
     ): Result<Unit>
 
-    suspend fun sendTransactionWriteResponseFailure(
+    suspend fun sendWalletInteractionResponseFailure(
         requestId: String,
         error: WalletErrorType,
         message: String? = null
@@ -37,6 +45,13 @@ interface DAppMessenger {
         requestId: String,
         txId: String
     ): Result<Unit>
+
+    suspend fun sendWalletInteractionSuccessResponse(
+        interactionId: String,
+        persona: OnNetwork.Persona,
+        oneTimeAccounts: List<AccountItemUiModel> = emptyList(),
+        ongoingAccounts: List<AccountItemUiModel> = emptyList()
+    ): Result<Unit>
 }
 
 class DAppMessengerImpl @Inject constructor(
@@ -48,13 +63,12 @@ class DAppMessengerImpl @Inject constructor(
         requestId: String,
         accounts: List<AccountItemUiModel>
     ): Result<Unit> {
-        val responseItem = OneTimeAccountsWithoutProofOfOwnershipResponseItem(
-            requestType = OneTimeAccountsRequestType.ONE_TIME_ACCOUNTS_READ.requestType,
+        val responseItem = OneTimeAccountsWithoutProofOfOwnershipRequestResponseItem(
             accounts = accounts.toDataModel()
         )
-        val walletResponse = WalletResponse(
-            requestId = requestId,
-            items = listOf(responseItem)
+        val walletResponse: WalletInteractionResponse = WalletInteractionSuccessResponse(
+            interactionId = requestId,
+            items = WalletUnauthorizedRequestResponseItems(oneTimeAccounts = responseItem)
         )
         val json = Json.encodeToString(walletResponse)
 
@@ -75,14 +89,9 @@ class DAppMessengerImpl @Inject constructor(
         txId: String
     ): Result<Unit> {
         val message = Json.encodeToString(
-            WalletResponse(
-                requestId = requestId,
-                items = listOf(
-                    SendTransactionResponseItem(
-                        requestType = SendTransactionResponseItem.REQUEST_TYPE,
-                        transactionIntentHash = txId
-                    )
-                )
+            WalletInteractionSuccessResponse(
+                interactionId = requestId,
+                items = WalletTransactionResponseItems(SendTransactionResponseItem(txId))
             )
         )
         return when (peerdroidClient.sendMessage(message)) {
@@ -94,14 +103,14 @@ class DAppMessengerImpl @Inject constructor(
         }
     }
 
-    override suspend fun sendTransactionWriteResponseFailure(
+    override suspend fun sendWalletInteractionResponseFailure(
         requestId: String,
         error: WalletErrorType,
         message: String?
     ): Result<Unit> {
         val messageJson = Json.encodeToString(
-            WalletErrorResponse(
-                requestId = requestId,
+            WalletInteractionFailureResponse(
+                interactionId = requestId,
                 error = error,
                 message = message
             )
@@ -114,4 +123,54 @@ class DAppMessengerImpl @Inject constructor(
             }
         }
     }
+
+    override suspend fun sendWalletInteractionSuccessResponse(
+        interactionId: String,
+        persona: OnNetwork.Persona,
+        oneTimeAccounts: List<AccountItemUiModel>,
+        ongoingAccounts: List<AccountItemUiModel>
+    ): Result<Unit> {
+        val walletSuccessResponse: WalletInteractionResponse = WalletInteractionSuccessResponse(
+            interactionId = interactionId,
+            items = WalletAuthorizedRequestResponseItems(
+                auth = AuthLoginWithoutChallengeRequestResponseItem(
+                    PersonaDto(
+                        persona.address,
+                        persona.displayName
+                    )
+                ),
+                oneTimeAccounts = if (oneTimeAccounts.isNotEmpty()) {
+                    OneTimeAccountsWithoutProofOfOwnershipRequestResponseItem(
+                        oneTimeAccounts.map {
+                            AccountDto(it.address, it.displayName.orEmpty(), it.appearanceID)
+                        }
+                    )
+                } else {
+                    null
+                },
+                ongoingAccounts = if (ongoingAccounts.isNotEmpty()) {
+                    OngoingAccountsWithoutProofOfOwnershipRequestResponseItem(
+                        ongoingAccounts.map {
+                            AccountDto(it.address, it.displayName.orEmpty(), it.appearanceID)
+                        }
+                    )
+                } else {
+                    null
+                }
+            )
+        )
+        val messageJson = try {
+            Json.encodeToString(walletSuccessResponse)
+        } catch (e: Exception) {
+            Timber.d(e)
+            ""
+        }
+        return when (peerdroidClient.sendMessage(messageJson)) {
+            is rdx.works.peerdroid.helpers.Result.Error -> Result.Error()
+            is rdx.works.peerdroid.helpers.Result.Success -> {
+                incomingRequestRepository.requestHandled(interactionId)
+                Result.Success(Unit)
+            }
+        }
+    }
 }