additional tests for transactions and fixes

jstuczyn · jstuczyn · commit 75e509cc4fc1 · 2025-02-14T09:13:16.000Z
diff --git a/common/cosmwasm-smart-contracts/nym-pool-contract/src/error.rs b/common/cosmwasm-smart-contracts/nym-pool-contract/src/error.rs
@@ -44,11 +44,8 @@ pub enum NymPoolContractError {
         current_block_timestamp: u64,
     },
 
-    #[error("there are not enough tokens to process this grant. {available} are available, but {requested_grant} was requested.")]
-    InsufficientTokens {
-        available: Coin,
-        requested_grant: Coin,
-    },
+    #[error("there are not enough tokens to process this request. {available} are available, but {required} is needed.")]
+    InsufficientTokens { available: Coin, required: Coin },
 
     #[error("the period length can't be zero")]
     ZeroAllowancePeriod,
@@ -95,4 +92,7 @@ pub enum NymPoolContractError {
 
     #[error("the associated grant hasn't expired yet")]
     GrantNotExpired,
+
+    #[error("this grant is not available yet. it will become usable at {available_at_timestamp}")]
+    GrantNotYetAvailable { available_at_timestamp: u64 },
 }
diff --git a/common/cosmwasm-smart-contracts/nym-pool-contract/src/types.rs b/common/cosmwasm-smart-contracts/nym-pool-contract/src/types.rs
@@ -159,12 +159,16 @@ pub mod grants {
 
         // check whether given the current allowance state, the provided amount could be spent
         // note: it's responsibility of the caller to call `try_update_state` before the call.
-        pub fn can_spend(&self, env: &Env, amount: &Coin) -> bool {
+        pub fn ensure_can_spend(
+            &self,
+            env: &Env,
+            amount: &Coin,
+        ) -> Result<(), NymPoolContractError> {
             match self {
-                Allowance::Basic(allowance) => allowance.can_spend(env, amount),
-                Allowance::ClassicPeriodic(allowance) => allowance.can_spend(env, amount),
-                Allowance::CumulativePeriodic(allowance) => allowance.can_spend(env, amount),
-                Allowance::Delayed(allowance) => allowance.can_spend(env, amount),
+                Allowance::Basic(allowance) => allowance.ensure_can_spend(env, amount),
+                Allowance::ClassicPeriodic(allowance) => allowance.ensure_can_spend(env, amount),
+                Allowance::CumulativePeriodic(allowance) => allowance.ensure_can_spend(env, amount),
+                Allowance::Delayed(allowance) => allowance.ensure_can_spend(env, amount),
             }
         }
 
@@ -255,14 +259,18 @@ pub mod grants {
             spend_limit.amount >= amount.amount
         }
 
-        fn can_spend(&self, env: &Env, amount: &Coin) -> bool {
-            !self.expired(env) && self.within_spendable_limits(amount)
+        fn ensure_can_spend(&self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
+            if self.expired(env) {
+                return Err(NymPoolContractError::GrantExpired);
+            }
+            if !self.within_spendable_limits(amount) {
+                return Err(NymPoolContractError::SpendingAboveAllowance);
+            }
+            Ok(())
         }
 
         fn try_spend(&mut self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
-            if !self.can_spend(env, amount) {
-                return Err(NymPoolContractError::SpendingAboveAllowance);
-            }
+            self.ensure_can_spend(env, amount)?;
 
             if let Some(ref mut spend_limit) = self.spend_limit {
                 spend_limit.amount -= amount.amount;
@@ -391,14 +399,18 @@ pub mod grants {
             available.amount >= amount.amount
         }
 
-        fn can_spend(&self, env: &Env, amount: &Coin) -> bool {
-            !self.basic.expired(env) && self.within_spendable_limits(amount)
+        fn ensure_can_spend(&self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
+            if self.basic.expired(env) {
+                return Err(NymPoolContractError::GrantExpired);
+            }
+            if !self.within_spendable_limits(amount) {
+                return Err(NymPoolContractError::SpendingAboveAllowance);
+            }
+            Ok(())
         }
 
         fn try_spend(&mut self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
-            if !self.can_spend(env, amount) {
-                return Err(NymPoolContractError::SpendingAboveAllowance);
-            }
+            self.ensure_can_spend(env, amount)?;
 
             // deduct from both the current period and the max amount
             if let Some(ref mut spend_limit) = self.basic.spend_limit {
@@ -567,14 +579,18 @@ pub mod grants {
             available.amount >= amount.amount
         }
 
-        fn can_spend(&self, env: &Env, amount: &Coin) -> bool {
-            !self.basic.expired(env) && self.within_spendable_limits(amount)
+        fn ensure_can_spend(&self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
+            if self.basic.expired(env) {
+                return Err(NymPoolContractError::GrantExpired);
+            }
+            if !self.within_spendable_limits(amount) {
+                return Err(NymPoolContractError::SpendingAboveAllowance);
+            }
+            Ok(())
         }
 
         fn try_spend(&mut self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
-            if !self.can_spend(env, amount) {
-                return Err(NymPoolContractError::SpendingAboveAllowance);
-            }
+            self.ensure_can_spend(env, amount)?;
 
             // deduct from both the current period and the max amount
             if let Some(ref mut spend_limit) = self.basic.spend_limit {
@@ -625,16 +641,24 @@ pub mod grants {
             self.basic.within_spendable_limits(amount)
         }
 
-        fn can_spend(&self, env: &Env, amount: &Coin) -> bool {
-            !self.basic.expired(env)
-                && self.within_spendable_limits(amount)
-                && self.available_at_unix_timestamp >= env.block.time.seconds()
+        fn ensure_can_spend(&self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
+            if self.basic.expired(env) {
+                return Err(NymPoolContractError::GrantExpired);
+            }
+            if !self.within_spendable_limits(amount) {
+                return Err(NymPoolContractError::SpendingAboveAllowance);
+            }
+            if self.available_at_unix_timestamp < env.block.time.seconds() {
+                return Err(NymPoolContractError::GrantNotYetAvailable {
+                    available_at_timestamp: self.available_at_unix_timestamp,
+                });
+            }
+
+            Ok(())
         }
 
         fn try_spend(&mut self, env: &Env, amount: &Coin) -> Result<(), NymPoolContractError> {
-            if !self.can_spend(env, amount) {
-                return Err(NymPoolContractError::SpendingAboveAllowance);
-            }
+            self.ensure_can_spend(env, amount)?;
 
             if let Some(ref mut spend_limit) = self.basic.spend_limit {
                 spend_limit.amount -= amount.amount;
diff --git a/contracts/nym-pool/src/contract.rs b/contracts/nym-pool/src/contract.rs
@@ -194,8 +194,7 @@ mod tests {
         mod setting_initial_grants {
             use super::*;
             use crate::testing::deps_with_balance;
-            use cosmwasm_std::testing::{MockApi, MockQuerier, MockStorage};
-            use cosmwasm_std::{coin, coins, Empty, MemoryStorage, Order, OwnedDeps, Storage};
+            use cosmwasm_std::{coin, Order, Storage};
             use nym_pool_contract_common::{Allowance, BasicAllowance, Grant, GranteeAddress};
             use std::collections::HashMap;
 
diff --git a/contracts/nym-pool/src/queries.rs b/contracts/nym-pool/src/queries.rs
@@ -183,9 +183,7 @@ mod tests {
     use super::*;
     use crate::contract::instantiate;
     use crate::testing::{TestSetup, TEST_DENOM};
-    use cosmwasm_std::testing::{
-        message_info, mock_dependencies, mock_dependencies_with_balance, mock_env,
-    };
+    use cosmwasm_std::testing::{message_info, mock_dependencies_with_balance, mock_env};
     use cosmwasm_std::{coin, Uint128};
     use nym_pool_contract_common::{Allowance, BasicAllowance, GranterInformation, InstantiateMsg};
 
@@ -564,7 +562,6 @@ mod tests {
     #[cfg(test)]
     mod grants_paged_query {
         use super::*;
-        use nym_pool_contract_common::GranteeAddress;
 
         fn grants_sorted(test: &mut TestSetup, count: usize) -> Vec<GrantInformation> {
             let mut grantees = Vec::new();
diff --git a/contracts/nym-pool/src/storage.rs b/contracts/nym-pool/src/storage.rs
@@ -78,7 +78,7 @@ impl NymPoolStorage {
             let balance = self.contract_balance(deps.as_ref(), &env)?;
             if required_amount > balance.amount || balance.amount.is_zero() {
                 return Err(NymPoolContractError::InsufficientTokens {
-                    requested_grant: coin(max(required_amount.u128(), 1), &balance.denom),
+                    required: coin(max(required_amount.u128(), 1), &balance.denom),
                     available: balance,
                 });
             }
@@ -243,7 +243,7 @@ impl NymPoolStorage {
             if spend_limit.amount > available.amount {
                 return Err(NymPoolContractError::InsufficientTokens {
                     available,
-                    requested_grant: spend_limit.clone(),
+                    required: spend_limit.clone(),
                 });
             }
         }
@@ -501,7 +501,7 @@ mod tests {
             use super::*;
             use crate::testing::{deps_with_balance, TEST_DENOM};
             use cosmwasm_std::testing::{mock_dependencies, mock_env};
-            use cosmwasm_std::{coin, MemoryStorage, Order};
+            use cosmwasm_std::{coin, Order};
             use nym_pool_contract_common::BasicAllowance;
 
             fn all_grants(storage: &dyn Storage) -> HashMap<GranteeAddress, Grant> {
@@ -1922,9 +1922,10 @@ mod tests {
                 let storage = NymPoolStorage::new();
                 let env = test.env();
                 let grantee = test.add_dummy_grant().grantee;
-                let amount = test.coin(100);
+                let amount1 = test.coin(100);
+                let amount2 = test.coin(200);
 
-                storage.lock_part_of_allowance(test.deps_mut(), &env, &grantee, amount)?;
+                storage.lock_part_of_allowance(test.deps_mut(), &env, &grantee, amount1)?;
                 assert_eq!(
                     storage.locked.grantee_locked(test.storage(), &grantee)?,
                     Uint128::new(100)
@@ -1934,6 +1935,17 @@ mod tests {
                     Uint128::new(100)
                 );
 
+                // more locked by same grantee
+                storage.lock_part_of_allowance(test.deps_mut(), &env, &grantee, amount2)?;
+                assert_eq!(
+                    storage.locked.grantee_locked(test.storage(), &grantee)?,
+                    Uint128::new(300)
+                );
+                assert_eq!(
+                    storage.locked.total_locked.load(test.storage())?,
+                    Uint128::new(300)
+                );
+
                 Ok(())
             }
         }
diff --git a/contracts/nym-pool/src/testing/mod.rs b/contracts/nym-pool/src/testing/mod.rs
@@ -107,6 +107,19 @@ impl TestSetup {
         }
     }
 
+    pub fn set_contract_balance(&mut self, balance: Coin) {
+        let contract_address = &self.contract_address;
+        self.app
+            .router()
+            .bank
+            .init_balance(
+                &mut self.storage.inner_storage(),
+                contract_address,
+                vec![balance],
+            )
+            .unwrap();
+    }
+
     pub fn deps(&self) -> Deps<'_> {
         Deps {
             storage: &self.storage,
diff --git a/contracts/nym-pool/src/testing/storage.rs b/contracts/nym-pool/src/testing/storage.rs
@@ -29,6 +29,12 @@ pub(crate) struct ContractStorageWrapper {
     inner: StorageWrapper,
 }
 
+impl ContractStorageWrapper {
+    pub fn inner_storage(&self) -> StorageWrapper {
+        self.inner.clone()
+    }
+}
+
 impl Storage for StorageWrapper {
     fn get(&self, key: &[u8]) -> Option<Vec<u8>> {
         self.0.borrow().get(key)
diff --git a/contracts/nym-pool/src/transactions.rs b/contracts/nym-pool/src/transactions.rs
