Staking: multitest improvements

contracts/stake/Cargo.toml

@@ -17,27 +17,22 @@ library = []
 
 [dependencies]
 dex = { workspace = true }
-# cw-plus
 cw-utils = { workspace = true }
 cw2 = { workspace = true }
 cw20 = { workspace = true }
 cw-controllers = { workspace = true }
 cw-storage-plus = { workspace = true }
-# core cosmwasm
 cosmwasm-std = { workspace = true }
 coreum-wasm-sdk = { workspace = true }
-# standard libs
 cosmwasm-schema = { workspace = true }
 serde = { workspace = true }
 thiserror = { workspace = true }
 wynd-curve-utils = { workspace = true }
 
 [dev-dependencies]
-# cw-plus
 cw-multi-test = { workspace = true }
 cw20-base = { workspace = true }
-# core cosmwasm
 cosmwasm-schema = { workspace = true }
-# standard libs
+bindings-test = { workspace = true }
 anyhow = { workspace = true }
 test-case = { workspace = true }

contracts/stake/src/lib.rs

@@ -12,8 +12,8 @@ pub mod msg;
 /// state on the blockchain
 pub mod state;
 
-// #[cfg(test)]
-// mod multitest;
+#[cfg(test)]
+mod multitest;
 /// some helper functions
 mod utils;
 pub use crate::error::ContractError;

contracts/stake/src/multitest.rs

@@ -1,7 +1,6 @@
-// mod delegate;
-// mod distribution;
-// mod migration;
-// mod quick_unbond;
-// mod staking_rewards;
+mod delegate;
+mod distribution;
+mod quick_unbond;
+mod staking_rewards;
 mod suite;
-// mod unbond_all;
+mod unbond_all;

contracts/stake/src/multitest/delegate.rs

@@ -1,25 +1,28 @@
+use super::suite::{SuiteBuilder, SEVEN_DAYS};
 use cosmwasm_std::Uint128;
 use cw_controllers::Claim;
 
-use super::suite::{SuiteBuilder, SEVEN_DAYS};
+const DENOM: &str = "VEST";
+const USER: &str = "user_addr_0000";
 
 #[test]
 fn delegate_and_unbond_tokens_still_vested() {
-    let user = "user";
+    let balances = vec![(USER, 100_000u128)];
     let mut suite = SuiteBuilder::new()
-        .with_initial_balances(vec![(user, 100_000)])
+        .with_native_balances(DENOM, balances)
+        .with_lp_share_denom(DENOM.to_string())
         .build();
 
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         100_000u128
     );
 
     // delegate half of the tokens, ensure they are staked
-    suite.delegate(user, 50_000u128, None).unwrap();
-    assert_eq!(suite.query_staked(user, None).unwrap(), 50_000u128);
+    suite.delegate(USER, 50_000u128, None).unwrap();
+    assert_eq!(suite.query_staked(USER, None).unwrap(), 50_000u128);
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         50_000u128
     );
     assert_eq!(
@@ -30,16 +33,16 @@ fn delegate_and_unbond_tokens_still_vested() {
     );
 
     // undelegate and unbond all
-    suite.unbond(user, 50_000u128, None).unwrap();
+    suite.unbond(USER, 50_000u128, None).unwrap();
     // nothing is staked
-    assert_eq!(suite.query_staked(user, None).unwrap(), 0u128);
+    assert_eq!(suite.query_staked(USER, None).unwrap(), 0u128);
     // Balance is the same until claim is available
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         50_000u128
     );
 
-    let claims = suite.query_claims(user).unwrap();
+    let claims = suite.query_claims(USER).unwrap();
     assert_eq!(claims.len(), 1);
     assert!(matches!(
         claims[0],
@@ -50,53 +53,56 @@ fn delegate_and_unbond_tokens_still_vested() {
     ));
 
     suite.update_time(SEVEN_DAYS * 2); // update height to simulate passing time
-    suite.claim(user).unwrap();
-    let claims = suite.query_claims(user).unwrap();
+    suite.claim(USER).unwrap();
+    let claims = suite.query_claims(USER).unwrap();
     assert_eq!(claims.len(), 0);
     // after expiration time passed, tokens can be claimed and transferred back to user account
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         100_000u128
     );
 }
 
 #[test]
 fn mixed_vested_liquid_delegate_and_transfer_remaining() {
-    let user = "user";
+    let balances = vec![(USER, 100_000u128)];
     let mut suite = SuiteBuilder::new()
-        .with_initial_balances(vec![(user, 100_000)])
+        .with_native_balances(DENOM, balances)
+        .with_lp_share_denom(DENOM.to_string())
         .build();
 
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         100_000u128
     );
 
-    suite.delegate(user, 60_000u128, None).unwrap(); // delegate some of vested tokens as well
-    assert_eq!(suite.query_staked(user, None).unwrap(), 60_000u128);
+    suite.delegate(USER, 60_000u128, None).unwrap(); // delegate some of vested tokens as well
+    assert_eq!(suite.query_staked(USER, None).unwrap(), 60_000u128);
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         40_000u128
     );
 
     // transfer remaining 40_000 to a different address, to show that vested tokens are delegated
     // first
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         40_000u128
     );
-    suite.transfer(user, "random_user", 40_000u128).unwrap();
+    suite
+        .transfer(USER, "random_user", (40_000u128, DENOM.to_string()))
+        .unwrap();
 
-    assert_eq!(suite.query_balance_vesting_contract(user).unwrap(), 0u128); // user has empty
+    assert_eq!(suite.query_balance_vesting_contract(USER).unwrap(), 0u128); // user has empty
                                                                             // account now
 
     // undelegate some of the tokens
-    suite.unbond(user, 20_000u128, None).unwrap();
-    assert_eq!(suite.query_staked(user, None).unwrap(), 40_000u128); // 60_000 delegated - 20_000
+    suite.unbond(USER, 20_000u128, None).unwrap();
+    assert_eq!(suite.query_staked(USER, None).unwrap(), 40_000u128); // 60_000 delegated - 20_000
                                                                      // unbonded
-    assert_eq!(suite.query_balance_vesting_contract(user).unwrap(), 0u128);
+    assert_eq!(suite.query_balance_vesting_contract(USER).unwrap(), 0u128);
 
-    let claims = suite.query_claims(user).unwrap();
+    let claims = suite.query_claims(USER).unwrap();
     assert!(matches!(
         claims[0],
         Claim {
@@ -106,59 +112,9 @@ fn mixed_vested_liquid_delegate_and_transfer_remaining() {
     ));
 
     suite.update_time(SEVEN_DAYS); // update height to simulate passing time
-    suite.claim(user).unwrap();
+    suite.claim(USER).unwrap();
     assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
+        suite.query_balance_vesting_contract(USER).unwrap(),
         20_000u128
     );
 }
-
-#[test]
-fn delegate_as_properly_assigned() {
-    let user = "factory";
-    let user2 = "client";
-    let mut suite = SuiteBuilder::new()
-        .with_initial_balances(vec![(user, 100_000)])
-        .build();
-
-    assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
-        100_000u128
-    );
-
-    // delegate half of the tokens, ensure they are staked
-    suite
-        .delegate_as(user, 50_000u128, None, Some(user2))
-        .unwrap();
-    assert_eq!(suite.query_staked(user, None).unwrap(), 0u128);
-    assert_eq!(suite.query_staked(user2, None).unwrap(), 50_000u128);
-    assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
-        50_000u128
-    );
-}
-
-#[test]
-fn mass_delegation_simple_case() {
-    let user = "factory";
-    let user2 = "client";
-    let mut suite = SuiteBuilder::new()
-        .with_initial_balances(vec![(user, 100_000)])
-        .build();
-
-    assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
-        100_000u128
-    );
-
-    // delegate half of the tokens, ensure they are staked
-    suite
-        .mass_delegate(user, 50_000u128, None, &[(user2, 50_000u128)])
-        .unwrap();
-    assert_eq!(suite.query_staked(user, None).unwrap(), 0u128);
-    assert_eq!(suite.query_staked(user2, None).unwrap(), 50_000u128);
-    assert_eq!(
-        suite.query_balance_vesting_contract(user).unwrap(),
-        50_000u128
-    );
-}