Use a struct to return expired claims data

Fix type_complexity warning

Author: maurolacy

contracts/tg4-stake/src/claim.rs

@@ -15,6 +15,18 @@ use tg_utils::Expiration;
 const MAX_LIMIT: u32 = 100;
 const DEFAULT_LIMIT: u32 = 30;
 
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct TokenReleaseInfo {
+    pub addr: Addr,
+    pub amount: Uint128,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub(crate) struct ReleaseData {
+    pub liquid_releases: Vec<TokenReleaseInfo>,
+    pub vesting_releases: Vec<TokenReleaseInfo>,
+}
+
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]
 pub struct Claim {
     /// Address owning the claim
@@ -154,14 +166,14 @@ impl<'a> Claims<'a> {
 
     /// This iterates over all mature claims of any addresses, and removes them. Up to `limit`
     /// claims would be processed, starting from the oldest. It removes the finished claims and
-    /// returns vector of pairs: `(addr, amount)`, representing amount of tokens to be released to particular addresses
-    #[allow(clippy::type_complexity)]
-    pub fn claim_expired(
+    /// returns a pair of vectors representing the amounts of liquid and vesting tokens
+    /// to be released to particular addresses.
+    pub(crate) fn claim_expired(
         &self,
         storage: &mut dyn Storage,
         block: &BlockInfo,
         limit: impl Into<Option<u64>>,
-    ) -> StdResult<(Vec<(Addr, Uint128)>, Vec<(Addr, Uint128)>)> {
+    ) -> StdResult<ReleaseData> {
         let claims = self
             .claims
             .idx
@@ -183,7 +195,10 @@ impl<'a> Claims<'a> {
             // is stabilized [https://github.com/rust-lang/rust/issues/80552]
             .group_by(|claim| &claim.addr)
             .into_iter()
-            .map(|(addr, group)| (addr.clone(), group.map(|claim| claim.amount).sum()))
+            .map(|(addr, group)| TokenReleaseInfo {
+                addr: addr.clone(),
+                amount: group.map(|claim| claim.amount).sum(),
+            })
             .collect();
 
         let vesting_releases = claims
@@ -192,19 +207,22 @@ impl<'a> Claims<'a> {
             // is stabilized [https://github.com/rust-lang/rust/issues/80552]
             .group_by(|claim| &claim.addr)
             .into_iter()
-            .map(|(addr, group)| {
-                (
-                    addr.clone(),
-                    group
-                        .map(|claim| claim.vesting_amount.unwrap_or_default())
-                        .sum(),
-                )
+            .map(|(addr, group)| TokenReleaseInfo {
+                addr: addr.clone(),
+                amount: group
+                    .map(|claim| claim.vesting_amount.unwrap_or_default())
+                    .sum(),
             })
             .collect();
 
         self.release_claims(storage, claims)?;
 
-        Ok((liquid_releases, vesting_releases))
+        let release_data = ReleaseData {
+            liquid_releases,
+            vesting_releases,
+        };
+
+        Ok(release_data)
     }
 
     /// Processes claims filtering those which are to be released. Returns vector of claims to be

contracts/tg4-stake/src/contract.rs

@@ -535,29 +535,31 @@ fn release_expired_claims<Q: CustomQuery>(
     env: Env,
     config: Config,
 ) -> Result<Vec<SubMsg>, ContractError> {
-    let (liquid_releases, vesting_releases) =
+    let release_data =
         claims().claim_expired(deps.storage, &env.block, config.auto_return_limit)?;
 
-    let send_msgs = liquid_releases
+    let send_msgs = release_data
+        .liquid_releases
         .into_iter()
-        .filter(|(_, amount)| !amount.is_zero())
-        .map(|(addr, amount)| {
-            let amount = coins(amount.into(), config.denom.clone());
+        .filter(|release_info| !release_info.amount.is_zero())
+        .map(|release_info| {
+            let amount = coins(release_info.amount.into(), config.denom.clone());
             Ok(SubMsg::new(BankMsg::Send {
-                to_address: addr.into(),
+                to_address: release_info.addr.into(),
                 amount,
             }))
         })
         .collect::<StdResult<Vec<_>>>()?;
 
-    let undelegate_msgs = vesting_releases
+    let undelegate_msgs = release_data
+        .vesting_releases
         .into_iter()
-        .filter(|(_, amount)| !amount.is_zero())
-        .map(|(addr, amount)| {
-            let amount = coin(amount.into(), config.denom.clone());
+        .filter(|release_info| !release_info.amount.is_zero())
+        .map(|release_info| {
+            let amount = coin(release_info.amount.into(), config.denom.clone());
             Ok(SubMsg::new(TgradeMsg::Undelegate {
                 funds: amount,
-                recipient: addr.to_string(),
+                recipient: release_info.addr.to_string(),
             }))
         })
         .collect::<StdResult<Vec<_>>>()?;