feat: execute all available claims

lklimek · lklimek · commit 29afd792713a · 2025-07-30T11:54:03.000+02:00
diff --git a/src/backend_task/mod.rs b/src/backend_task/mod.rs
@@ -99,6 +99,7 @@ pub enum BackendTaskSuccessResult {
     },
     UpdatedThemePreference(crate::ui::theme::ThemeMode),
     PlatformInfo(PlatformInfoTaskResult),
+    TokensClaimed(TokenAmount),
 }
 
 impl BackendTaskSuccessResult {}
diff --git a/src/backend_task/tokens/claim_tokens.rs b/src/backend_task/tokens/claim_tokens.rs
@@ -2,6 +2,9 @@ use crate::backend_task::BackendTaskSuccessResult;
 use crate::context::AppContext;
 use crate::model::proof_log_item::{ProofLogItem, RequestType};
 use crate::model::qualified_identity::QualifiedIdentity;
+use dash_sdk::dpp::ProtocolError;
+use dash_sdk::dpp::consensus::ConsensusError;
+use dash_sdk::dpp::consensus::state::state_error::StateError;
 use dash_sdk::dpp::data_contract::accessors::v1::DataContractV1Getters;
 use dash_sdk::dpp::data_contract::associated_token::token_distribution_key::TokenDistributionType;
 use dash_sdk::dpp::document::DocumentV0Getters;
@@ -14,8 +17,14 @@ use dash_sdk::{Error, Sdk};
 use std::sync::Arc;
 
 impl AppContext {
+    /// Claim all pending token claims matching the provided parameters.
+    ///
+    /// This method iterates until all tokens are claimed or no more claims are available.
+    ///
+    /// If no tokens are available to claim, it returns `TokensClaimed(0)`
+    /// (in contrary to the [AppContext::claim_token()] method which returns error).
     #[allow(clippy::too_many_arguments)]
-    pub async fn claim_tokens(
+    pub async fn claim_all_tokens(
         &self,
         data_contract: Arc<DataContract>,
         token_position: u16,
@@ -25,6 +34,71 @@ impl AppContext {
         public_note: Option<String>,
         sdk: &Sdk,
     ) -> Result<BackendTaskSuccessResult, String> {
+        let mut total_claimed = 0;
+        loop {
+            let result = self
+                .claim_token(
+                    data_contract.clone(),
+                    token_position,
+                    actor_identity,
+                    distribution_type,
+                    signing_key.clone(),
+                    public_note.clone(),
+                    sdk,
+                )
+                .await;
+
+            match result {
+                Ok(BackendTaskSuccessResult::TokensClaimed(0)) => {
+                    // If no tokens were claimed, we can exit the loop
+                    break;
+                }
+                Ok(BackendTaskSuccessResult::TokensClaimed(amount)) => {
+                    total_claimed += amount;
+                    // Continue to check for more tokens to claim
+                }
+                Err(dash_sdk::Error::Protocol(ProtocolError::ConsensusError(ce)))
+                    if matches!(
+                        *ce,
+                        ConsensusError::StateError(StateError::InvalidTokenClaimNoCurrentRewards(
+                            _
+                        )),
+                    ) =>
+                {
+                    // No more rewards available, exit the loop
+                    break;
+                }
+                // ConsensusError::StateError(StateError::InvalidTokenClaimNoCurrentRewards(as_refected)))) if as_expected,
+
+                // any other result we propagate
+                Ok(x) => return Ok(x),
+                Err(e) => {
+                    return Err(format!(
+                        "Error claiming tokens: {}; claimed so far: {}",
+                        e, total_claimed
+                    ));
+                }
+            }
+        }
+
+        // Return the total claimed amount.
+        Ok(BackendTaskSuccessResult::TokensClaimed(total_claimed))
+    }
+
+    /// Execute single token claim.
+    ///
+    /// This method will return error if no tokens were available to claim.
+    #[allow(clippy::too_many_arguments)]
+    pub async fn claim_token(
+        &self,
+        data_contract: Arc<DataContract>,
+        token_position: u16,
+        actor_identity: &QualifiedIdentity,
+        distribution_type: TokenDistributionType,
+        signing_key: IdentityPublicKey,
+        public_note: Option<String>,
+        sdk: &Sdk,
+    ) -> Result<BackendTaskSuccessResult, dash_sdk::Error> {
         // Build
         let mut builder = TokenClaimTransitionBuilder::new(
             data_contract.clone(),
@@ -45,7 +119,7 @@ impl AppContext {
         let result = sdk
             .token_claim(builder, &signing_key, actor_identity)
             .await
-            .map_err(|e| match e {
+            .inspect_err(|e|{ match e {
                 Error::DriveProofError(proof_error, proof_bytes, block_info) => {
                     self.db
                         .insert_proof_log_item(ProofLogItem {
@@ -54,19 +128,18 @@ impl AppContext {
                             verification_path_query_bytes: vec![],
                             height: block_info.height,
                             time_ms: block_info.time_ms,
-                            proof_bytes,
+                            proof_bytes: proof_bytes.clone(),
                             error: Some(proof_error.to_string()),
                         })
                         .ok();
-                    format!(
-                        "Error broadcasting ClaimTokens transition: {}, proof error logged",
-                        proof_error
-                    )
+                    tracing::error!(error=?proof_error, "Error broadcasting ClaimTokens transition, proof error logged");
                 }
-                e => format!("Error broadcasting ClaimTokens transition: {}", e),
-            })?;
+                e => tracing::error!(error=?e, "Error broadcasting ClaimTokens transition"),
+            };
+        })?;
 
         // Using the result, update the balance of the claimer identity
+        let mut claimed_amount = 0;
         if let Some(token_id) = data_contract.token_id(token_position) {
             match result {
                 // Standard claim result - extract claimer and amount from document
@@ -77,15 +150,15 @@ impl AppContext {
                         if let (Value::Identifier(claimer_bytes), Value::U64(amount)) =
                             (claimer_value, amount_value)
                         {
+                            claimed_amount = *amount;
                             if let Ok(claimer_id) = Identifier::from_bytes(claimer_bytes) {
                                 if let Err(e) = self.insert_token_identity_balance(
                                     &token_id,
                                     &claimer_id,
                                     *amount,
                                 ) {
-                                    eprintln!(
-                                        "Failed to update token balance from claim document: {}",
-                                        e
+                                    tracing::error!(error=?e, identity=?claimer_id, token_id=?token_id,
+                                        "Failed to update token balance from claim document",
                                     );
                                 }
                             }
@@ -101,15 +174,15 @@ impl AppContext {
                         if let (Value::Identifier(claimer_bytes), Value::U64(amount)) =
                             (claimer_value, amount_value)
                         {
+                            claimed_amount = *amount;
                             if let Ok(claimer_id) = Identifier::from_bytes(claimer_bytes) {
                                 if let Err(e) = self.insert_token_identity_balance(
                                     &token_id,
                                     &claimer_id,
                                     *amount,
                                 ) {
-                                    eprintln!(
-                                        "Failed to update token balance from group action document: {}",
-                                        e
+                                    tracing::error!(error=?e, identity=?claimer_id, token_id=?token_id,
+                                        "Failed to update token balance from group action document",
                                     );
                                 }
                             }
@@ -120,6 +193,6 @@ impl AppContext {
         }
 
         // Return success
-        Ok(BackendTaskSuccessResult::Message("ClaimTokens".to_string()))
+        Ok(BackendTaskSuccessResult::TokensClaimed(claimed_amount))
     }
 }
diff --git a/src/backend_task/tokens/mod.rs b/src/backend_task/tokens/mod.rs
@@ -488,7 +488,7 @@ impl AppContext {
                 signing_key,
                 public_note,
             } => self
-                .claim_tokens(
+                .claim_all_tokens(
                     data_contract.clone(),
                     *token_position,
                     actor_identity,
diff --git a/src/ui/tokens/claim_tokens_screen.rs b/src/ui/tokens/claim_tokens_screen.rs
@@ -20,7 +20,7 @@ use dash_sdk::dpp::identity::{KeyType, Purpose, SecurityLevel};
 use eframe::egui::{self, Color32, Context, Ui};
 use egui::RichText;
 use crate::app::{AppAction, BackendTasksExecutionMode};
-use crate::backend_task::BackendTask;
+use crate::backend_task::{BackendTask, BackendTaskSuccessResult};
 use crate::backend_task::tokens::TokenTask;
 use crate::context::AppContext;
 use crate::model::qualified_contract::QualifiedContract;
@@ -248,6 +248,25 @@ impl ClaimTokensScreen {
 }
 
 impl ScreenLike for ClaimTokensScreen {
+    fn display_task_result(
+        &mut self,
+        backend_task_success_result: crate::backend_task::BackendTaskSuccessResult,
+    ) {
+        if let BackendTaskSuccessResult::TokensClaimed(amount) = backend_task_success_result {
+            if amount > 0 {
+                self.display_message(
+                    &format!("Claimed {} tokens successfully!", amount),
+                    MessageType::Success,
+                );
+                self.status = ClaimTokensStatus::Complete;
+            } else {
+                // self.display_message("No tokens available to claim.", MessageType::Error);
+                self.status =
+                    ClaimTokensStatus::ErrorMessage("No tokens available to claim.".to_string());
+            }
+        }
+    }
+
     fn display_message(&mut self, message: &str, message_type: MessageType) {
         match message_type {
             MessageType::Success => {

Original file line number	Diff line number	Diff line change
`@@ -99,6 +99,7 @@ pub enum BackendTaskSuccessResult {`
`99`	`99`	`},`
`100`	`100`	`UpdatedThemePreference(crate::ui::theme::ThemeMode),`
`101`	`101`	`PlatformInfo(PlatformInfoTaskResult),`
	`102`	`+ TokensClaimed(TokenAmount),`
`102`	`103`	`}`
`103`	`104`
`104`	`105`	`impl BackendTaskSuccessResult {}`