WAL-1588 Sponsored delegation (#349)

zaiatsartem · web-flow · commit 9cdc19c97b22 · 2026-03-20T12:56:17.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -10,6 +10,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 
 - Support for sponsored Smart contract updates
+- Support for sponsored delegation configuration transaction
 
 ### Fixed
 
diff --git a/app/src/main/java/com/concordium/wallet/data/walletconnect/AccountTransactionPayload.kt b/app/src/main/java/com/concordium/wallet/data/walletconnect/AccountTransactionPayload.kt
@@ -1,5 +1,6 @@
 package com.concordium.wallet.data.walletconnect
 
+import com.concordium.sdk.responses.transactionstatus.DelegationTarget
 import com.concordium.sdk.transactions.tokens.TransferTokenOperation
 import com.concordium.sdk.types.ContractAddress
 import com.google.gson.annotations.SerializedName
@@ -22,18 +23,24 @@ sealed interface AccountTransactionPayload {
         val maxContractExecutionEnergy: Long?,
         val message: String,
         val receiveName: String
-    ): AccountTransactionPayload
+    ) : AccountTransactionPayload
 
     data class Transfer(
         val amount: BigInteger,
         @SerializedName("to", alternate = ["toAddress"])
         val toAddress: String
-    ): AccountTransactionPayload
+    ) : AccountTransactionPayload
 
     data class PltTransfer(
         val tokenId: String,
         val transfer: TransferTokenOperation,
-    ): AccountTransactionPayload
+    ) : AccountTransactionPayload
+
+    data class ConfigureDelegation(
+        val amount: BigInteger,
+        val restakeEarnings: Boolean,
+        val delegationTarget: DelegationTarget?
+    ) : AccountTransactionPayload
 
     // InitContract is not needed for now.
 }
diff --git a/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectSignSponsoredTransactionRequestHandler.kt b/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectSignSponsoredTransactionRequestHandler.kt
@@ -2,6 +2,7 @@ package com.concordium.wallet.ui.walletconnect
 
 import android.content.Context
 import com.concordium.sdk.serializing.JsonMapper
+import com.concordium.sdk.transactions.ConfigureDelegation
 import com.concordium.sdk.transactions.PartiallySignedSponsoredTransaction
 import com.concordium.sdk.transactions.Payload
 import com.concordium.sdk.transactions.SignerEntry
@@ -121,6 +122,14 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
                     )
                 }
 
+                is ConfigureDelegation -> {
+                    AccountTransactionPayload.ConfigureDelegation(
+                        amount = BigInteger(1, payload.capital?.value?.bytes),
+                        restakeEarnings = payload.restakeEarnings ?: false,
+                        delegationTarget = payload.delegationTarget
+                    )
+                }
+
                 else ->
                     error("The wallet only supports CCD and token transfers")
             }
@@ -181,7 +190,8 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
             token = try {
                 when (val transactionPayload = this.transactionPayload) {
                     is AccountTransactionPayload.Transfer,
-                    is AccountTransactionPayload.Update
+                    is AccountTransactionPayload.Update,
+                    is AccountTransactionPayload.ConfigureDelegation
                         ->
                         CCDToken(
                             account = account,
@@ -228,6 +238,7 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
 
         val method = getTransactionMethodName(transactionPayload)
         val accountAtDisposalBalance = account.balanceAtDisposal
+        val accountCooldownBalance = account.cooldownAmount
         val sponsorAddress = partiallySignedTransaction.header.sponsor.get().toString()
 
         val reviewState = when (val transactionPayload = this.transactionPayload) {
@@ -241,6 +252,7 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
                     account = account,
                     canShowDetails = false,
                     isEnoughFunds = transactionPayload.amount <= accountAtDisposalBalance,
+                    showCooldownWarning = false,
                     sponsor = sponsorAddress,
                     appMetadata = appMetadata,
                 )
@@ -255,6 +267,7 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
                     account = account,
                     canShowDetails = true,
                     isEnoughFunds = transactionPayload.amount <= accountAtDisposalBalance,
+                    showCooldownWarning = false,
                     sponsor = sponsorAddress,
                     appMetadata = appMetadata,
                 )
@@ -272,10 +285,31 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
                     account = account,
                     canShowDetails = transactionPayload.transfer.memo.isPresent,
                     isEnoughFunds = tokenAmount <= token.balance,
+                    showCooldownWarning = false,
                     sponsor = sponsorAddress,
                     appMetadata = appMetadata,
                 )
             }
+
+            is AccountTransactionPayload.ConfigureDelegation -> {
+                State.SessionRequestReview.TransactionRequestReview(
+                    method = method,
+                    receiver = transactionPayload.delegationTarget?.type?.name ?: "",
+                    amount = transactionPayload.amount,
+                    token = token,
+                    estimatedFee = BigInteger.ZERO,
+                    account = account,
+                    canShowDetails = true,
+                    isEnoughFunds = transactionPayload.amount <= accountAtDisposalBalance + accountCooldownBalance,
+                    showCooldownWarning = transactionPayload.amount < account.delegatedAmount,
+                    sponsor = sponsorAddress,
+                    delegationRestakeEarnings = transactionPayload.restakeEarnings,
+                    delegationType = transactionPayload.delegationTarget?.bakerId?.id?.toString()
+                        ?: context.getString(R.string.delegation_register_delegation_passive_long),
+                    delegationPoolId = transactionPayload.delegationTarget?.bakerId?.id?.toString() ?: "",
+                    appMetadata = appMetadata,
+                )
+            }
         }
 
         emitState(reviewState)
@@ -390,6 +424,16 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
                     )
                 )
             }
+
+            is AccountTransactionPayload.ConfigureDelegation -> {
+
+                emitEvent(
+                    Event.ShowDetailsDialog(
+                        title = getTransactionMethodName(transactionPayload),
+                        prettyPrintDetails = context.getString(R.string.wallet_connect_transaction_request_no_details),
+                    )
+                )
+            }
         }
     }
 
@@ -409,6 +453,9 @@ class WalletConnectSignSponsoredTransactionRequestHandler(
 
             is AccountTransactionPayload.Update ->
                 transactionPayload.receiveName
+
+            is AccountTransactionPayload.ConfigureDelegation ->
+                context.getString(R.string.wallet_connect_delegation_configuration)
         }
 
     companion object {
diff --git a/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectSignTransactionRequestHandler.kt b/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectSignTransactionRequestHandler.kt
@@ -163,7 +163,7 @@ class WalletConnectSignTransactionRequestHandler(
                 when (val transactionPayload = this.transactionPayload) {
                     is AccountTransactionPayload.Transfer,
                     is AccountTransactionPayload.Update,
-                    ->
+                        ->
                         CCDToken(
                             account = account,
                             withTotalBalance = true,
@@ -183,6 +183,8 @@ class WalletConnectSignTransactionRequestHandler(
                                         && it.tokenId == transactionPayload.tokenId
                             }
                             ?: error("Missing the requested token ${transactionPayload.tokenId}")
+
+                    else -> error("The wallet only supports CCD and token transfers")
                 }
             } catch (error: Exception) {
                 Log.e("failed_loading_token", error)
@@ -224,6 +226,7 @@ class WalletConnectSignTransactionRequestHandler(
                     account = account,
                     canShowDetails = false,
                     isEnoughFunds = transactionPayload.amount + transactionCost.cost <= accountAtDisposalBalance,
+                    showCooldownWarning = false,
                     sponsor = null,
                     appMetadata = appMetadata,
                 )
@@ -238,6 +241,7 @@ class WalletConnectSignTransactionRequestHandler(
                     account = account,
                     canShowDetails = true,
                     isEnoughFunds = transactionPayload.amount + transactionCost.cost <= accountAtDisposalBalance,
+                    showCooldownWarning = false,
                     sponsor = null,
                     appMetadata = appMetadata,
                 )
@@ -256,10 +260,13 @@ class WalletConnectSignTransactionRequestHandler(
                     canShowDetails = transactionPayload.transfer.memo.isPresent,
                     isEnoughFunds = transactionCost.cost <= accountAtDisposalBalance
                             && tokenAmount <= token.balance,
+                    showCooldownWarning = false,
                     sponsor = null,
                     appMetadata = appMetadata,
                 )
             }
+
+            else -> error("The wallet only supports CCD and token transfers")
         }
 
         emitState(reviewState)
@@ -278,6 +285,7 @@ class WalletConnectSignTransactionRequestHandler(
             is AccountTransactionPayload.PltTransfer -> getProtocolLevelTokenTransferCost(
                 pltTransferPayload = transactionPayload,
             )
+            else -> error("The wallet only supports CCD and token transfers")
         }
 
     private suspend fun getTransferCost(
@@ -382,6 +390,8 @@ class WalletConnectSignTransactionRequestHandler(
                         pltTransferPayload = transactionPayload,
                         signer = accountKeys.getSignerEntry(),
                     )
+
+                else -> error("The wallet only supports CCD and token transfers")
             }
 
             respondSuccess(App.appCore.gson.toJson(TransactionSuccess(submissionId)))
@@ -531,6 +541,8 @@ class WalletConnectSignTransactionRequestHandler(
                     )
                 )
             }
+
+            else -> error("The wallet only supports CCD and token transfers")
         }
     }
 
@@ -546,11 +558,13 @@ class WalletConnectSignTransactionRequestHandler(
         when (transactionPayload) {
             is AccountTransactionPayload.Transfer,
             is AccountTransactionPayload.PltTransfer,
-            ->
+                ->
                 context.getString(R.string.transaction_type_transfer)
 
             is AccountTransactionPayload.Update ->
                 transactionPayload.receiveName
+
+            else -> error("The wallet only supports CCD and token transfers")
         }
 
     companion object {
diff --git a/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectView.kt b/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectView.kt
@@ -72,7 +72,7 @@ class WalletConnectView(
             when (state) {
                 is WalletConnectViewModel.State.SessionProposalReview,
                 is WalletConnectViewModel.State.SessionRequestReview,
-                -> {
+                    -> {
                     val lifecycleState = lifecycle.currentState
                     if (lifecycleState >= Lifecycle.State.CREATED
                         && lifecycleState < Lifecycle.State.STARTED
@@ -137,8 +137,12 @@ class WalletConnectView(
                     estimatedFee = state.estimatedFee,
                     canShowDetails = state.canShowDetails,
                     isEnoughFunds = state.isEnoughFunds,
+                    showCooldownWarning = state.showCooldownWarning,
                     sponsor = state.sponsor,
                     account = state.account,
+                    delegationRestakeEarnings = state.delegationRestakeEarnings,
+                    delegationType = state.delegationType,
+                    delegationPoolId = state.delegationPoolId,
                     appMetadata = state.appMetadata,
                 )
             }
@@ -223,7 +227,7 @@ class WalletConnectView(
                 val duration = when (event.error) {
                     WalletConnectViewModel.Error.ConnectionFailed,
                     WalletConnectViewModel.Error.AccountNotFound,
-                    ->
+                        ->
                         Toast.LENGTH_LONG
 
                     else ->
@@ -355,8 +359,12 @@ class WalletConnectView(
         estimatedFee: BigInteger,
         canShowDetails: Boolean,
         isEnoughFunds: Boolean,
+        showCooldownWarning: Boolean,
         sponsor: String?,
         account: Account,
+        delegationRestakeEarnings: Boolean,
+        delegationType: String,
+        delegationPoolId: String,
         appMetadata: WalletConnectViewModel.AppMetadata,
     ) {
         getShownBottomSheet().showTransactionRequestReview { (view, lifecycleOwner) ->
@@ -370,8 +378,12 @@ class WalletConnectView(
                 estimatedFee = estimatedFee,
                 canShowDetails = canShowDetails,
                 isEnoughFunds = isEnoughFunds,
+                showCooldownWarning = showCooldownWarning,
                 sponsor = sponsor,
                 account = account,
+                delegationRestakeEarnings = delegationRestakeEarnings,
+                delegationType = delegationType,
+                delegationPoolId = delegationPoolId,
                 appMetadata = appMetadata,
             )
         }
@@ -388,8 +400,12 @@ class WalletConnectView(
         estimatedFee: BigInteger,
         canShowDetails: Boolean,
         isEnoughFunds: Boolean,
+        showCooldownWarning: Boolean,
         sponsor: String?,
         account: Account,
+        delegationRestakeEarnings: Boolean,
+        delegationType: String,
+        delegationPoolId: String,
         appMetadata: WalletConnectViewModel.AppMetadata,
     ) = with(view) {
         Glide.with(appIconImageView.context)
@@ -462,6 +478,17 @@ class WalletConnectView(
             sponsoredLabel.isVisible = false
         }
 
+        if (delegationType.isNotEmpty()) {
+            transactionDataLayout.isVisible = false
+            delegationDataLayout.isVisible = true
+            delegationTarget.text = delegationPoolId.ifEmpty { delegationType }
+            delegationRewards.text =
+                if (delegationRestakeEarnings) root.context.getString(R.string.delegation_status_added_to_delegation_amount)
+                else root.context.getString(R.string.delegation_status_at_disposal)
+        } else {
+            delegationDataLayout.isVisible = false
+        }
+
         errorTextView.isVisible = !isEnoughFunds
         errorTextView.text =
             when {
@@ -481,6 +508,8 @@ class WalletConnectView(
             }
         }
 
+        delegationWarning.isVisible = showCooldownWarning
+
         declineButton.setOnClickListener {
             viewModel.rejectSessionRequest()
         }
diff --git a/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectViewModel.kt b/app/src/main/java/com/concordium/wallet/ui/walletconnect/WalletConnectViewModel.kt
@@ -1259,7 +1259,11 @@ private constructor(
                 val estimatedFee: BigInteger,
                 val canShowDetails: Boolean,
                 val isEnoughFunds: Boolean,
+                val showCooldownWarning: Boolean,
                 val sponsor: String?,
+                val delegationRestakeEarnings: Boolean = false,
+                val delegationType: String = "",
+                val delegationPoolId: String = "",
                 account: Account,
                 appMetadata: AppMetadata,
             ) : SessionRequestReview(
diff --git a/app/src/main/res/layout/fragment_wallet_connect_transaction_request_review.xml b/app/src/main/res/layout/fragment_wallet_connect_transaction_request_review.xml
diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml

Original file line number	Diff line number	Diff line change
`@@ -163,7 +163,7 @@ class WalletConnectSignTransactionRequestHandler(`
`163`	`163`	`when (val transactionPayload = this.transactionPayload) {`
`164`	`164`	`is AccountTransactionPayload.Transfer,`
`165`	`165`	`is AccountTransactionPayload.Update,`
`166`		`- ->`
	`166`	`+ ->`
`167`	`167`	`CCDToken(`
`168`	`168`	`account = account,`
`169`	`169`	`withTotalBalance = true,`
`@@ -183,6 +183,8 @@ class WalletConnectSignTransactionRequestHandler(`
`183`	`183`	`&& it.tokenId == transactionPayload.tokenId`
`184`	`184`	`}`
`185`	`185`	`?: error("Missing the requested token ${transactionPayload.tokenId}")`
	`186`	`+`
	`187`	`+ else -> error("The wallet only supports CCD and token transfers")`
`186`	`188`	`}`
`187`	`189`	`} catch (error: Exception) {`
`188`	`190`	`Log.e("failed_loading_token", error)`
`@@ -224,6 +226,7 @@ class WalletConnectSignTransactionRequestHandler(`
`224`	`226`	`account = account,`
`225`	`227`	`canShowDetails = false,`
`226`	`228`	`isEnoughFunds = transactionPayload.amount + transactionCost.cost <= accountAtDisposalBalance,`
	`229`	`+ showCooldownWarning = false,`
`227`	`230`	`sponsor = null,`
`228`	`231`	`appMetadata = appMetadata,`
`229`	`232`	`)`
`@@ -238,6 +241,7 @@ class WalletConnectSignTransactionRequestHandler(`
`238`	`241`	`account = account,`
`239`	`242`	`canShowDetails = true,`
`240`	`243`	`isEnoughFunds = transactionPayload.amount + transactionCost.cost <= accountAtDisposalBalance,`
	`244`	`+ showCooldownWarning = false,`
`241`	`245`	`sponsor = null,`
`242`	`246`	`appMetadata = appMetadata,`
`243`	`247`	`)`
`@@ -256,10 +260,13 @@ class WalletConnectSignTransactionRequestHandler(`
`256`	`260`	`canShowDetails = transactionPayload.transfer.memo.isPresent,`
`257`	`261`	`isEnoughFunds = transactionCost.cost <= accountAtDisposalBalance`
`258`	`262`	`&& tokenAmount <= token.balance,`
	`263`	`+ showCooldownWarning = false,`
`259`	`264`	`sponsor = null,`
`260`	`265`	`appMetadata = appMetadata,`
`261`	`266`	`)`
`262`	`267`	`}`
	`268`	`+`
	`269`	`+ else -> error("The wallet only supports CCD and token transfers")`
`263`	`270`	`}`
`264`	`271`
`265`	`272`	`emitState(reviewState)`
`@@ -278,6 +285,7 @@ class WalletConnectSignTransactionRequestHandler(`
`278`	`285`	`is AccountTransactionPayload.PltTransfer -> getProtocolLevelTokenTransferCost(`
`279`	`286`	`pltTransferPayload = transactionPayload,`
`280`	`287`	`)`
	`288`	`+ else -> error("The wallet only supports CCD and token transfers")`
`281`	`289`	`}`
`282`	`290`
`283`	`291`	`private suspend fun getTransferCost(`
`@@ -382,6 +390,8 @@ class WalletConnectSignTransactionRequestHandler(`
`382`	`390`	`pltTransferPayload = transactionPayload,`
`383`	`391`	`signer = accountKeys.getSignerEntry(),`
`384`	`392`	`)`
	`393`	`+`
	`394`	`+ else -> error("The wallet only supports CCD and token transfers")`
`385`	`395`	`}`
`386`	`396`
`387`	`397`	`respondSuccess(App.appCore.gson.toJson(TransactionSuccess(submissionId)))`
`@@ -531,6 +541,8 @@ class WalletConnectSignTransactionRequestHandler(`
`531`	`541`	`)`
`532`	`542`	`)`
`533`	`543`	`}`
	`544`	`+`
	`545`	`+ else -> error("The wallet only supports CCD and token transfers")`
`534`	`546`	`}`
`535`	`547`	`}`
`536`	`548`
`@@ -546,11 +558,13 @@ class WalletConnectSignTransactionRequestHandler(`
`546`	`558`	`when (transactionPayload) {`
`547`	`559`	`is AccountTransactionPayload.Transfer,`
`548`	`560`	`is AccountTransactionPayload.PltTransfer,`
`549`		`- ->`
	`561`	`+ ->`
`550`	`562`	`context.getString(R.string.transaction_type_transfer)`
`551`	`563`
`552`	`564`	`is AccountTransactionPayload.Update ->`
`553`	`565`	`transactionPayload.receiveName`
	`566`	`+`
	`567`	`+ else -> error("The wallet only supports CCD and token transfers")`
`554`	`568`	`}`
`555`	`569`
`556`	`570`	`companion object {`