ve3-shared 0.9.1

ve(3,3) msgs in cosmwasm
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

use crate::{
  error::SharedError,
  msgs_asset_staking::{
    AssetDistribution, Cw20HookMsg, ExecuteMsg, QueryMsg, WhitelistedAssetsResponse,
  },
};
use cosmwasm_std::{coins, to_json_binary, Addr, CosmosMsg, QuerierWrapper, WasmMsg};
use cw20::Cw20ExecuteMsg;
use cw_asset::{Asset, AssetInfo};

pub struct AssetStaking(pub Addr);

impl AssetStaking {
  pub fn claim_rewards_msg(
    &self,
    assets: Option<Vec<AssetInfo>>,
  ) -> Result<CosmosMsg, SharedError> {
    Ok(CosmosMsg::Wasm(WasmMsg::Execute {
      contract_addr: self.0.to_string(),
      msg: to_json_binary(&ExecuteMsg::ClaimRewards {
        assets,
      })?,
      funds: vec![],
    }))
  }
  pub fn claim_reward_msg(&self, asset: AssetInfo) -> Result<CosmosMsg, SharedError> {
    Ok(CosmosMsg::Wasm(WasmMsg::Execute {
      contract_addr: self.0.to_string(),
      msg: to_json_binary(&ExecuteMsg::ClaimReward(asset))?,
      funds: vec![],
    }))
  }

  pub fn deposit_msg(&self, asset: Asset) -> Result<CosmosMsg, SharedError> {
    match asset.info {
      cw_asset::AssetInfoBase::Native(native) => Ok(CosmosMsg::Wasm(WasmMsg::Execute {
        contract_addr: self.0.to_string(),
        msg: to_json_binary(&ExecuteMsg::Stake {
          recipient: None,
        })?,
        funds: coins(asset.amount.u128(), native),
      })),
      cw_asset::AssetInfoBase::Cw20(contract_addr) => Ok(CosmosMsg::Wasm(WasmMsg::Execute {
        contract_addr: contract_addr.to_string(),
        funds: vec![],
        msg: to_json_binary(&Cw20ExecuteMsg::Send {
          contract: self.0.to_string(),
          amount: asset.amount,
          msg: to_json_binary(&Cw20HookMsg::Stake {
            recipient: None,
          })?,
        })?,
      })),
      _ => Err(SharedError::NotSupported("asset type".to_string())),
    }
  }

  pub fn withdraw_msg(&self, asset: Asset) -> Result<CosmosMsg, SharedError> {
    Ok(CosmosMsg::Wasm(WasmMsg::Execute {
      contract_addr: self.0.to_string(),
      msg: to_json_binary(&ExecuteMsg::Unstake(asset))?,
      funds: vec![],
    }))
  }

  pub fn set_reward_distribution_msg(
    &self,
    distribution: Vec<AssetDistribution>,
  ) -> Result<CosmosMsg, SharedError> {
    Ok(CosmosMsg::Wasm(WasmMsg::Execute {
      contract_addr: self.0.to_string(),
      msg: to_json_binary(&ExecuteMsg::SetAssetRewardDistribution(distribution))?,
      funds: vec![],
    }))
  }

  pub fn query_whitelisted_assets(
    &self,
    querier: &QuerierWrapper,
  ) -> Result<WhitelistedAssetsResponse, SharedError> {
    let assets: WhitelistedAssetsResponse =
      querier.query_wasm_smart(self.0.clone(), &QueryMsg::WhitelistedAssets {})?;
    Ok(assets)
  }

  pub fn query_whitelisted_assets_str(
    &self,
    querier: &QuerierWrapper,
  ) -> Result<Vec<String>, SharedError> {
    Ok(
      self
        .query_whitelisted_assets(querier)?
        .into_iter()
        .map(|a| a.to_string())
        .collect::<Vec<_>>(),
    )
  }
}