fix: unimplemented whale info methods

Author: fragwuerdig

build.sh

@@ -3,4 +3,4 @@
 docker run --rm -v "$(pwd)":/code \
   --mount type=volume,source="$(basename "$(pwd)")_cache",target=/target \
   --mount type=volume,source=registry_cache,target=/usr/local/cargo/registry \
-  cosmwasm/optimizer:0.16.0
+  cosmwasm/optimizer:0.15.0

contracts/cw20-taxed/src/contract.rs

@@ -27,7 +27,7 @@ use crate::state::{
 };
 
 use crate::tax::TaxMap;
-use crate::whale::{self, WhaleInfo};
+use crate::whale::{self, execute_set_whale_admin, execute_set_whale_info, WhaleInfo};
 
 // version info for migration info
 pub const CONTRACT_NAME: &str = "crates.io:cw20-base";
@@ -266,8 +266,21 @@ pub fn execute(
         ExecuteMsg::SetTaxAdmin { tax_admin } => execute_set_tax_admin(deps, env, info, tax_admin),
 
         // WhaleInfo related extension
-        ExecuteMsg::SetWhaleInfo { whale_info } => panic!("Not implemented"),
-        ExecuteMsg::SetWhaleAdmin { whale_admin } => panic!("Not implemented"),
+        ExecuteMsg::SetWhaleInfo { whale_info } => {
+            match whale_info {
+                Some(x) => execute_set_whale_info(deps, env, info, x),
+                None => { Ok(Response::new()) }
+            }
+        },
+        ExecuteMsg::SetWhaleAdmin { whale_admin } => {
+            match whale_admin {
+                Some(x) => {
+                    let new_addr = deps.api.addr_validate(x.as_str())?;
+                    execute_set_whale_admin(deps, env, info, new_addr)
+                }
+                None => { Ok(Response::new()) }
+            }
+        },
     }
 }
 

contracts/cw20-taxed/src/whale.rs

@@ -1,6 +1,11 @@
+use std::char::REPLACEMENT_CHARACTER;
+
+use cosmwasm_std::{DepsMut, Env, MessageInfo, Response};
 use cosmwasm_std::{Addr, Decimal, StdError, StdResult, Storage, Uint128};
+use crate::ContractError;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
+use crate::state::ANTI_WHALE_INFO;
 
 use crate::state::TOKEN_INFO;
 
@@ -54,9 +59,44 @@ impl WhaleInfo {
     }
 }
 
+pub fn execute_set_whale_info(
+    deps: DepsMut,
+    env: Env, info: MessageInfo,
+    whale_info: WhaleInfo
+) -> Result<Response, ContractError> {
+    let mut old_whale_info = ANTI_WHALE_INFO.load(deps.storage)?;
+    whale_info.validate()?;
+    if info.sender != old_whale_info.admin {
+        return Err(ContractError::Unauthorized {});
+    }
+    ANTI_WHALE_INFO.save(deps.storage, &whale_info)?;
+    Ok(Response::new())
+}
+
+pub fn execute_set_whale_admin(
+    deps: DepsMut,
+    env: Env,
+    info: MessageInfo,
+    admin: Addr
+) -> Result<Response, ContractError> {
+    let mut old_info = ANTI_WHALE_INFO.load(deps.storage)?;
+    if info.sender != old_info.admin {
+        return Err(ContractError::Unauthorized{});
+    }
+    old_info.admin = admin;
+    ANTI_WHALE_INFO.save(deps.storage, &old_info)?;
+    Ok(Response::new())
+}
+
 #[cfg(test)]
 mod test {
-    use cosmwasm_std::{testing::MockStorage, Addr, Decimal, Uint128};
+    use std::ops::Add;
+
+    use cosmwasm_std::{
+        testing::{mock_dependencies, mock_env, mock_info, MockStorage}, Addr, Decimal, Uint128
+    };
+    use crate::ContractError;
+    use serde::de;
 
     use crate::state::TokenInfo;
 
@@ -132,4 +172,97 @@ mod test {
         assert!(info.assert_no_whale(storage, &addr3, whale_amount).is_err());
         assert!(info.assert_no_whale(storage, &addr3, fish_amount).is_ok());
     }
+
+    #[test]
+    fn test_set_whale_info_works() {
+        let mut deps = mock_dependencies();
+        let info = mock_info("admin", &[]);
+        let expected_whale_info = super::WhaleInfo {
+            threshold: Decimal::percent(10),
+            whitelist: vec![Addr::unchecked("whale1"), Addr::unchecked("whale2")],
+            admin: Addr::unchecked("admin"),
+        };
+
+        // mock info being set by instantiation
+        super::ANTI_WHALE_INFO.save(deps.as_mut().storage, &super::WhaleInfo {
+            threshold: Decimal::one(),
+            whitelist: vec![],
+            admin: Addr::unchecked("admin"),
+        }).unwrap();
+
+        super::execute_set_whale_info(deps.as_mut(), mock_env(), info, expected_whale_info).unwrap();
+
+        let new_info = super::ANTI_WHALE_INFO.load(deps.as_ref().storage).unwrap();
+        assert_eq!(new_info, new_info);
+        
+    }
+
+    #[test]
+    fn test_set_whale_info_rejects_no_admin() {
+        let mut deps = mock_dependencies();
+        let info = mock_info("no_admin", &[]);
+        let expected_whale_info = super::WhaleInfo {
+            threshold: Decimal::percent(10),
+            whitelist: vec![Addr::unchecked("whale1"), Addr::unchecked("whale2")],
+            admin: Addr::unchecked("admin"),
+        };
+
+        // mock info being set by instantiation
+        super::ANTI_WHALE_INFO.save(deps.as_mut().storage, &super::WhaleInfo {
+            threshold: Decimal::one(),
+            whitelist: vec![],
+            admin: Addr::unchecked("admin"),
+        }).unwrap();
+
+        let err = super::execute_set_whale_info(deps.as_mut(), mock_env(), info, expected_whale_info);
+        match err {
+            Ok(_) => { panic!("expected failrue"); },
+            Err(e) => {
+                assert_eq!( e, ContractError::Unauthorized {  } )
+            }
+        }
+        
+    }
+
+    #[test]
+    fn test_set_whale_admin() {
+        let mut deps = mock_dependencies();
+        let info = mock_info("admin", &[]);
+        let old_whale_info = super::WhaleInfo {
+            threshold: Decimal::percent(10),
+            whitelist: vec![Addr::unchecked("whale1"), Addr::unchecked("whale2")],
+            admin: Addr::unchecked("admin"),
+        };
+        let mut expected_whale_info = old_whale_info.clone();
+        expected_whale_info.admin = Addr::unchecked("admin2");
+
+        // mock info being set by instantiation
+        super::ANTI_WHALE_INFO.save(deps.as_mut().storage, &old_whale_info).unwrap();
+
+        super::execute_set_whale_admin(deps.as_mut(), mock_env(), info, Addr::unchecked("admin2")).unwrap();
+
+        let new_info = super::ANTI_WHALE_INFO.load(deps.as_mut().storage).unwrap();
+        assert_eq!(new_info, expected_whale_info)
+    }
+
+    #[test]
+    fn test_set_whale_admin_unauthorized() {
+        let mut deps = mock_dependencies();
+        let info = mock_info("no_admin", &[]);
+        let old_whale_info = super::WhaleInfo {
+            threshold: Decimal::percent(10),
+            whitelist: vec![Addr::unchecked("whale1"), Addr::unchecked("whale2")],
+            admin: Addr::unchecked("admin"),
+        };
+
+        // mock info being set by instantiation
+        super::ANTI_WHALE_INFO.save(deps.as_mut().storage, &old_whale_info).unwrap();
+
+        let res = super::execute_set_whale_admin(deps.as_mut(), mock_env(), info, Addr::unchecked("admin2"));
+        match res {
+            Ok(_) => {panic!("unexpected success of setting admin!")},
+            Err(e) => {assert_eq!(e, ContractError::Unauthorized {  })}
+        }
+
+    }
 }