chore(lst): staker tests

Author: benluelo

Cargo.toml

@@ -391,7 +391,7 @@ ibc-union-msg          = { path = "cosmwasm/ibc-union/core/msg", default-feature
 
 frissitheto = { path = "lib/frissitheto", default-features = false }
 
-access-manager       = { path = "cosmwasm/access-manager", default-features = false }
+access-manager = { path = "cosmwasm/access-manager", default-features = false }
 
 lst = { path = "cosmwasm/lst", default-features = false }
 

cosmwasm/lst-staker/src/lib.rs

@@ -178,7 +178,6 @@ fn withdraw_all_rewards(
 
     // NOTE: Sum the individual rewards, *NOT* the total rewards
     // if there are rewards of 1.5 and 0.5, the total will be 2.0 (even after flooring it), but the *actual* claimable amount is floor(1.5) + floor(0.5), which is 1
-    // TODO: Add a test for this
     let total_pending_rewards = delegation_total_rewards
         .rewards
         .iter()

cosmwasm/lst-staker/src/tests.rs

@@ -1,18 +1,22 @@
 use std::collections::BTreeMap;
 
 use cosmwasm_std::{
+    from_json,
     testing::{message_info, mock_dependencies, mock_env, MockApi, MockQuerier, MockStorage},
-    Addr, Event, Order, OwnedDeps, Response, Uint128,
+    to_json_binary, Addr, ContractResult, DecCoin, Decimal, DistributionMsg, Event, Order,
+    OwnedDeps, QuerierResult, Response, Uint128, WasmQuery,
 };
 use cw_account::{
     state::{Admins, Zkgm},
     types::{Admin, LocalAdmin},
 };
 use depolama::StorageExt;
+use lst::{msg::ConfigResponse, types::ProtocolFeeConfig};
 
-use crate::{execute, msg::ExecuteMsg, ContractError};
+use crate::{execute, msg::ExecuteMsg, withdraw_all_rewards, ContractError};
 
 const ADMIN: &str = "admin";
+const LST_HUB: &str = "lst-hub";
 
 fn setup_local() -> OwnedDeps<MockStorage, MockApi, MockQuerier> {
     let mut deps = mock_dependencies();
@@ -41,6 +45,14 @@ fn setup_local() -> OwnedDeps<MockStorage, MockApi, MockQuerier> {
     // zkgm does not exist after a local admin init
     assert!(deps.storage.maybe_read_item::<Zkgm>().unwrap().is_none());
 
+    execute(
+        deps.as_mut(),
+        mock_env(),
+        message_info(&Addr::unchecked(ADMIN), &[]),
+        ExecuteMsg::SetLstHubAddress(Addr::unchecked(LST_HUB)),
+    )
+    .unwrap();
+
     deps
 }
 
@@ -108,7 +120,7 @@ fn admin_ops_require_admin() {
 fn lst_ops_require_lst() {
     let mut deps = setup_local();
 
-    let lst_hub = Addr::unchecked("lst-hub");
+    let lst_hub = Addr::unchecked(LST_HUB);
     let non_admin = Addr::unchecked("non-admin");
 
     assert_eq!(
@@ -149,3 +161,84 @@ fn lst_ops_require_lst() {
         },
     );
 }
+
+#[test]
+fn withdraw_all_rewards_floors_correctly() {
+    let mut deps = setup_local();
+    let env = mock_env();
+
+    deps.querier.update_wasm(|w| match w {
+        WasmQuery::Smart { contract_addr, msg } => match &**contract_addr {
+            LST_HUB => match from_json::<lst::msg::QueryMsg>(msg).unwrap() {
+                lst::msg::QueryMsg::Config {} => QuerierResult::Ok(ContractResult::Ok(
+                    to_json_binary(&ConfigResponse {
+                        native_token_denom: "au".to_owned(),
+                        minimum_liquid_stake_amount: Default::default(),
+                        protocol_fee_config: ProtocolFeeConfig {
+                            fee_rate: Default::default(),
+                            fee_recipient: "".to_owned(),
+                        },
+                        monitors: Default::default(),
+                        lst_address: Addr::unchecked(""),
+                        staker_address: Addr::unchecked(""),
+                        batch_period_seconds: Default::default(),
+                        unbonding_period_seconds: Default::default(),
+                        stopped: Default::default(),
+                    })
+                    .unwrap(),
+                )),
+                _ => todo!(),
+            },
+            _ => todo!(),
+        },
+        _ => todo!(),
+    });
+
+    let (native_token_denom, total_pending_rewards, withdraw_msgs) =
+        withdraw_all_rewards(deps.as_ref(), &env).unwrap();
+
+    assert_eq!(native_token_denom, "au");
+    assert_eq!(total_pending_rewards, Uint128::zero());
+    assert_eq!(withdraw_msgs.collect::<Vec<_>>(), vec![]);
+
+    deps.querier.distribution.set_rewards(
+        "val-1",
+        &env.contract.address,
+        vec![DecCoin::new("1.5".parse::<Decimal>().unwrap(), "au")],
+    );
+
+    let (native_token_denom, total_pending_rewards, withdraw_msgs) =
+        withdraw_all_rewards(deps.as_ref(), &env).unwrap();
+
+    assert_eq!(native_token_denom, "au");
+    assert_eq!(total_pending_rewards, Uint128::new(1));
+    assert_eq!(
+        withdraw_msgs.collect::<Vec<_>>(),
+        vec![DistributionMsg::WithdrawDelegatorReward {
+            validator: "val-1".to_owned()
+        }]
+    );
+
+    deps.querier.distribution.set_rewards(
+        "val-2",
+        &env.contract.address,
+        vec![DecCoin::new("0.5".parse::<Decimal>().unwrap(), "au")],
+    );
+
+    let (native_token_denom, total_pending_rewards, withdraw_msgs) =
+        withdraw_all_rewards(deps.as_ref(), &env).unwrap();
+
+    assert_eq!(native_token_denom, "au");
+    assert_eq!(total_pending_rewards, Uint128::new(1));
+    assert_eq!(
+        withdraw_msgs.collect::<Vec<_>>(),
+        vec![
+            DistributionMsg::WithdrawDelegatorReward {
+                validator: "val-1".to_owned()
+            },
+            DistributionMsg::WithdrawDelegatorReward {
+                validator: "val-2".to_owned()
+            }
+        ]
+    );
+}

cosmwasm/lst/src/tests/bond_tests.rs

@@ -61,15 +61,15 @@
 use cosmwasm_std::{
     coins,
     testing::{message_info, mock_env},
-    to_json_binary, Addr, BankMsg, CosmosMsg, Decimal, Event, StdError, WasmMsg,
+    to_json_binary, wasm_execute, Addr, CosmosMsg, Decimal, Event, StdError, WasmMsg,
 };
 use cw20::Cw20ExecuteMsg;
 use depolama::StorageExt;
 
 use crate::{
     contract::execute,
     error::ContractError,
-    msg::ExecuteMsg,
+    msg::{ExecuteMsg, StakerExecuteMsg},
     query::query_state,
     state::AccountingStateStore,
     tests::test_helper::{
@@ -92,13 +92,17 @@ fn bond_without_pending_rewards() {
 
     let res = execute(deps.as_mut(), mock_env(), info.clone(), msg.clone()).unwrap();
 
-    // the native funds are sent to the staker
+    // the native funds are staked
     assert_eq!(
         res.messages[0].msg,
-        CosmosMsg::Bank(BankMsg::Send {
-            to_address: STAKER_ADDRESS.into(),
-            amount: info.funds.clone()
-        })
+        CosmosMsg::Wasm(
+            wasm_execute(
+                STAKER_ADDRESS.to_owned(),
+                &StakerExecuteMsg::Stake {},
+                coins(1000, NATIVE_TOKEN)
+            )
+            .unwrap()
+        ),
     );
 
     // 1000 LST token is minted to the `mint_to` address.