Merge pull request #221 from juggernaut09/juggernaut/Add-cw20-support

Juggernaut/add cw20 support

Author: ethanfrey

Cargo.lock

@@ -142,9 +142,7 @@ pub fn check_staking_permissions(
                 return Err(ContractError::WithdrawPerm {});
             }
         }
-        s => {
-            panic!("Unsupported staking message: {:?}", s)
-        }
+        s => panic!("Unsupported staking message: {:?}", s),
     }
     Ok(true)
 }

contracts/cw1-subkeys/src/contract.rs

@@ -29,6 +29,7 @@ library = []
 cw0 = { path = "../../packages/cw0", version = "0.5.0" }
 cw2 = { path = "../../packages/cw2", version = "0.5.0" }
 cw4 = { path = "../../packages/cw4", version = "0.5.0" }
+cw20 = { path = "../../packages/cw20", version = "0.5.0" }
 cw-controllers = { path = "../../packages/controllers", version = "0.5.0" }
 cw-storage-plus = { path = "../../packages/storage-plus", version = "0.5.0", features = ["iterator"] }
 cosmwasm-std = { version = "0.14.0-alpha2" }

contracts/cw4-stake/Cargo.toml

@@ -21,7 +21,11 @@
     },
     "denom": {
       "description": "denom of the token to stake",
-      "type": "string"
+      "allOf": [
+        {
+          "$ref": "#/definitions/Denom"
+        }
+      ]
     },
     "min_bond": {
       "$ref": "#/definitions/Uint128"
@@ -34,6 +38,39 @@
     }
   },
   "definitions": {
+    "Binary": {
+      "description": "Binary is a wrapper around Vec<u8> to add base64 de/serialization with serde. It also adds some helper methods to help encode inline.\n\nThis is only needed as serde-json-{core,wasm} has a horrible encoding for Vec<u8>",
+      "type": "string"
+    },
+    "CanonicalAddr": {
+      "$ref": "#/definitions/Binary"
+    },
+    "Denom": {
+      "anyOf": [
+        {
+          "type": "object",
+          "required": [
+            "native"
+          ],
+          "properties": {
+            "native": {
+              "type": "string"
+            }
+          }
+        },
+        {
+          "type": "object",
+          "required": [
+            "cw20"
+          ],
+          "properties": {
+            "cw20": {
+              "$ref": "#/definitions/CanonicalAddr"
+            }
+          }
+        }
+      ]
+    },
     "Duration": {
       "description": "Duration is a delta of time. You can add it to a BlockInfo or Expiration to move that further in the future. Note that an height-based Duration and a time-based Expiration cannot be combined",
       "anyOf": [

contracts/cw4-stake/schema/init_msg.json

@@ -1,9 +1,11 @@
 use cosmwasm_std::{
     attr, coin, coins, to_binary, BankMsg, Binary, CanonicalAddr, Coin, CosmosMsg, Deps, DepsMut,
-    Env, HumanAddr, MessageInfo, Order, Response, StdResult, Storage, Uint128,
+    Env, HumanAddr, MessageInfo, Order, Response, StdError, StdResult, Storage, Uint128,
 };
-use cw0::maybe_canonical;
+
+use cw0::{maybe_canonical, NativeBalance};
 use cw2::set_contract_version;
+use cw20::{Balance, Denom};
 use cw4::{
     Member, MemberChangedHookMsg, MemberDiff, MemberListResponse, MemberResponse,
     TotalWeightResponse,
@@ -58,42 +60,46 @@ pub fn execute(
         HandleMsg::UpdateAdmin { admin } => Ok(ADMIN.execute_update_admin(deps, info, admin)?),
         HandleMsg::AddHook { addr } => Ok(HOOKS.execute_add_hook(&ADMIN, deps, info, addr)?),
         HandleMsg::RemoveHook { addr } => Ok(HOOKS.execute_remove_hook(&ADMIN, deps, info, addr)?),
-        HandleMsg::Bond {} => execute_bond(deps, env, info),
+        HandleMsg::Bond {} => execute_bond(deps, env, Balance::from(info.funds), info.sender),
         HandleMsg::Unbond { tokens: amount } => execute_unbond(deps, env, info, amount),
         HandleMsg::Claim {} => execute_claim(deps, env, info),
     }
 }
 
-pub fn execute_bond(deps: DepsMut, env: Env, info: MessageInfo) -> Result<Response, ContractError> {
+pub fn execute_bond(
+    deps: DepsMut,
+    env: Env,
+    amount: Balance,
+    sender: HumanAddr,
+) -> Result<Response, ContractError> {
     let cfg = CONFIG.load(deps.storage)?;
 
     // ensure the sent denom was proper
     // NOTE: those clones are not needed (if we move denom, we return early),
     // but the compiler cannot see that (yet...)
-    let sent = match info.funds.len() {
-        0 => Err(ContractError::NoFunds {}),
-        1 => {
-            if info.funds[0].denom == cfg.denom {
-                Ok(info.funds[0].amount)
+    let amount = match (&cfg.denom, &amount) {
+        (Denom::Native(want), Balance::Native(have)) => must_pay_funds(have, want),
+        (Denom::Cw20(want), Balance::Cw20(have)) => {
+            if want == &have.address {
+                Ok(have.amount)
             } else {
-                Err(ContractError::MissingDenom(cfg.denom.clone()))
+                Err(ContractError::InvalidDenom(deps.api.human_address(&want)?))
             }
         }
-        _ => Err(ContractError::ExtraDenoms(cfg.denom.clone())),
+        _ => Err(ContractError::MixedNativeAndCw20(
+            "Invalid address or denom".to_string(),
+        )),
     }?;
-    if sent.is_zero() {
-        return Err(ContractError::NoFunds {});
-    }
 
     // update the sender's stake
-    let sender_raw = deps.api.canonical_address(&info.sender)?;
+    let sender_raw = deps.api.canonical_address(&sender)?;
     let new_stake = STAKE.update(deps.storage, &sender_raw, |stake| -> StdResult<_> {
-        Ok(stake.unwrap_or_default() + sent)
+        Ok(stake.unwrap_or_default() + amount)
     })?;
 
     let messages = update_membership(
         deps.storage,
-        info.sender.clone(),
+        sender.clone(),
         &sender_raw,
         new_stake,
         &cfg,
@@ -102,8 +108,8 @@ pub fn execute_bond(deps: DepsMut, env: Env, info: MessageInfo) -> Result<Respon
 
     let attributes = vec![
         attr("action", "bond"),
-        attr("amount", sent),
-        attr("sender", info.sender),
+        attr("amount", amount),
+        attr("sender", sender),
     ];
     Ok(Response {
         submessages: vec![],
@@ -156,6 +162,22 @@ pub fn execute_unbond(
     })
 }
 
+pub fn must_pay_funds(balance: &NativeBalance, denom: &str) -> Result<Uint128, ContractError> {
+    match balance.0.len() {
+        0 => Err(ContractError::NoFunds {}),
+        1 => {
+            let balance = &balance.0;
+            let payment = balance[0].amount;
+            if balance[0].denom == denom {
+                Ok(payment)
+            } else {
+                Err(ContractError::MissingDenom(denom.to_string()))
+            }
+        }
+        _ => Err(ContractError::ExtraDenoms(denom.to_string())),
+    }
+}
+
 fn update_membership(
     storage: &mut dyn Storage,
     sender: HumanAddr,
@@ -211,9 +233,15 @@ pub fn execute_claim(
     }
 
     let config = CONFIG.load(deps.storage)?;
-    let amount = coins(release.u128(), config.denom);
-    let amount_str = coins_to_string(&amount);
+    let amount;
+    match &config.denom {
+        Denom::Native(denom) => amount = coins(release.u128(), denom),
+        Denom::Cw20(_canonical_addr) => {
+            unimplemented!("The CW20 coins release functionality is in progress")
+        }
+    }
 
+    let amount_str = coins_to_string(&amount);
     let messages = vec![BankMsg::Send {
         to_address: info.sender.clone(),
         amount,
@@ -269,7 +297,14 @@ pub fn query_staked(deps: Deps, address: HumanAddr) -> StdResult<StakedResponse>
     let stake = STAKE
         .may_load(deps.storage, &address_raw)?
         .unwrap_or_default();
-    let denom = CONFIG.load(deps.storage)?.denom;
+    let denom = match CONFIG.load(deps.storage)?.denom {
+        Denom::Native(want) => want,
+        _ => {
+            return Err(StdError::generic_err(
+                "The stake for CW20 is not yet implemented",
+            ));
+        }
+    };
     Ok(StakedResponse {
         stake: coin(stake.u128(), denom),
     })
@@ -315,18 +350,21 @@ fn list_members(
 
 #[cfg(test)]
 mod tests {
-    use super::*;
     use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
     use cosmwasm_std::{from_slice, Api, StdError, Storage};
     use cw0::Duration;
+    use cw20::Denom;
     use cw4::{member_key, TOTAL_KEY};
     use cw_controllers::{AdminError, Claim, HookError};
 
+    use crate::error::ContractError;
+
+    use super::*;
+
     const INIT_ADMIN: &str = "juan";
     const USER1: &str = "somebody";
     const USER2: &str = "else";
     const USER3: &str = "funny";
-
     const DENOM: &str = "stake";
     const TOKENS_PER_WEIGHT: Uint128 = Uint128(1_000);
     const MIN_BOND: Uint128 = Uint128(5_000);
@@ -348,7 +386,7 @@ mod tests {
         unbonding_period: Duration,
     ) {
         let msg = InitMsg {
-            denom: DENOM.to_string(),
+            denom: Denom::Native("stake".to_string()),
             tokens_per_weight,
             min_bond,
             unbonding_period,
@@ -528,7 +566,7 @@ mod tests {
                 assert_eq!(minuend.as_str(), "5000");
                 assert_eq!(subtrahend.as_str(), "5100");
             }
-            e => panic!("Unexpected error: {}", e),
+            e => panic!("Unexpected error: {:?}", e),
         }
     }
 

contracts/cw4-stake/src/contract.rs

@@ -1,4 +1,4 @@
-use cosmwasm_std::StdError;
+use cosmwasm_std::{HumanAddr, StdError};
 use thiserror::Error;
 
 use cw_controllers::{AdminError, HookError};
@@ -26,6 +26,12 @@ pub enum ContractError {
     #[error("Sent unsupported denoms, must send '{0}' to stake")]
     ExtraDenoms(String),
 
+    #[error("Must send valid address to stake")]
+    InvalidDenom(HumanAddr),
+
+    #[error("Missed address or denom")]
+    MixedNativeAndCw20(String),
+
     #[error("No funds sent")]
     NoFunds {},
 }

contracts/cw4-stake/src/error.rs

@@ -1,14 +1,15 @@
+use cosmwasm_std::{Coin, HumanAddr, Uint128};
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::{Coin, HumanAddr, Uint128};
 use cw0::Duration;
+use cw20::Denom;
 pub use cw_controllers::ClaimsResponse;
 
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 pub struct InitMsg {
     /// denom of the token to stake
-    pub denom: String,
+    pub denom: Denom,
     pub tokens_per_weight: Uint128,
     pub min_bond: Uint128,
     pub unbonding_period: Duration,

contracts/cw4-stake/src/msg.rs

@@ -1,8 +1,9 @@
+use cosmwasm_std::Uint128;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::Uint128;
 use cw0::Duration;
+use cw20::Denom;
 use cw4::TOTAL_KEY;
 use cw_controllers::{Admin, Claims, Hooks};
 use cw_storage_plus::{Item, Map, SnapshotMap, Strategy};
@@ -12,7 +13,7 @@ pub const CLAIMS: Claims = Claims::new("claims");
 #[derive(Serialize, Deserialize, Clone, PartialEq, JsonSchema, Debug)]
 pub struct Config {
     /// denom of the token to stake
-    pub denom: String,
+    pub denom: Denom,
     pub tokens_per_weight: Uint128,
     pub min_bond: Uint128,
     pub unbonding_period: Duration,

contracts/cw4-stake/src/state.rs

@@ -3,9 +3,10 @@ mod expiration;
 mod pagination;
 mod payment;
 
-pub use crate::balance::NativeBalance;
-pub use crate::expiration::{Duration, Expiration, DAY, HOUR, WEEK};
 pub use pagination::{
     calc_range_end_human, calc_range_start_human, calc_range_start_string, maybe_canonical,
 };
 pub use payment::{may_pay, must_pay, nonpayable, PaymentError};
+
+pub use crate::balance::NativeBalance;
+pub use crate::expiration::{Duration, Expiration, DAY, HOUR, WEEK};

packages/cw0/src/lib.rs

@@ -1,7 +1,7 @@
+use cosmwasm_std::Coin;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use cosmwasm_std::Coin;
 use cw0::NativeBalance;
 
 use crate::Cw20Coin;