Skip to content

Commit

Permalink
Merge pull request #98 from CosmWasm/cw-0.11.0-mask
Browse files Browse the repository at this point in the history 
mask: Migrate to cosmwasm v0.11.0
  • Loading branch information
@webmaster128
webmaster128 committed Oct 15, 2020
2 parents 3734286 + 40cf9b7 commit a9ca345
Show file tree
Hide file tree
Showing 6 changed files with 122 additions and 135 deletions.
21 changes: 11 additions & 10 deletions mask/Cargo.lock
View file

Some generated files are not rendered by default. Learn more about how customized files appear on GitHub.

9 changes: 5 additions & 4 deletions mask/Cargo.toml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -37,11 +37,12 @@ cranelift = ["cosmwasm-vm/default-cranelift"]
singlepass = ["cosmwasm-vm/default-singlepass"]

[dependencies]
cosmwasm-std = "0.10.0"
cosmwasm-storage = "0.10.0"
cosmwasm-std = "0.11.0"
cosmwasm-storage = "0.11.0"
thiserror = { version = "1.0.20" }
schemars = "0.7"
serde = { version = "1.0.103", default-features = false, features = ["derive"] }

[dev-dependencies]
cosmwasm-vm = { version = "0.10.0", default-features = false }
cosmwasm-schema = "0.10.0"
cosmwasm-vm = { version = "0.11.0", default-features = false }
cosmwasm-schema = "0.11.0"
133 changes: 73 additions & 60 deletions mask/src/contract.rs
View file
Original file line number Diff line number Diff line change
@@ -1,18 +1,20 @@
use cosmwasm_std::{
log, to_binary, Api, Binary, CosmosMsg, Env, Extern, HandleResponse, HandleResult, HumanAddr,
InitResponse, InitResult, Querier, StdError, StdResult, Storage,
attr, to_binary, Api, Binary, CosmosMsg, Env, Extern, HandleResponse, HumanAddr, InitResponse,
InitResult, MessageInfo, Querier, StdResult, Storage,
};

use crate::error::ContractError;
use crate::msg::{HandleMsg, InitMsg, OwnerResponse, QueryMsg};
use crate::state::{config, config_read, State};

pub fn init<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
_env: Env,
info: MessageInfo,
_msg: InitMsg,
) -> InitResult {
let state = State {
owner: deps.api.canonical_address(&env.message.sender)?,
owner: deps.api.canonical_address(&info.sender)?,
};

config(&mut deps.storage).save(&state)?;
Expand All @@ -23,55 +25,59 @@ pub fn init<S: Storage, A: Api, Q: Querier>(
pub fn handle<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
info: MessageInfo,
msg: HandleMsg,
) -> HandleResult {
) -> Result<HandleResponse, ContractError> {
match msg {
HandleMsg::ReflectMsg { msgs } => try_reflect(deps, env, msgs),
HandleMsg::ChangeOwner { owner } => try_change_owner(deps, env, owner),
HandleMsg::ReflectMsg { msgs } => try_reflect(deps, env, info, msgs),
HandleMsg::ChangeOwner { owner } => try_change_owner(deps, env, info, owner),
}
}

pub fn try_reflect<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
_: Env,
info: MessageInfo,
msgs: Vec<CosmosMsg>,
) -> HandleResult {
) -> Result<HandleResponse, ContractError> {
let state = config(&mut deps.storage).load()?;
if deps.api.canonical_address(&env.message.sender)? != state.owner {
return Err(StdError::unauthorized());
if deps.api.canonical_address(&info.sender)? != state.owner {
return Err(ContractError::Unauthorized {});
}
if msgs.is_empty() {
return Err(StdError::generic_err("Must reflect at least one message"));
return Err(ContractError::NoReflectMsg {});
}
let res = HandleResponse {
messages: msgs,
log: vec![log("action", "reflect")],
attributes: vec![attr("action", "reflect")],
data: None,
};
Ok(res)
}

pub fn try_change_owner<S: Storage, A: Api, Q: Querier>(
deps: &mut Extern<S, A, Q>,
env: Env,
_: Env,
info: MessageInfo,
owner: HumanAddr,
) -> HandleResult {
) -> Result<HandleResponse, ContractError> {
let api = deps.api;
config(&mut deps.storage).update(|mut state| {
if api.canonical_address(&env.message.sender)? != state.owner {
return Err(StdError::unauthorized());
if api.canonical_address(&info.sender)? != state.owner {
return Err(ContractError::Unauthorized {});
}
state.owner = api.canonical_address(&owner)?;
Ok(state)
})?;
Ok(HandleResponse {
log: vec![log("action", "change_owner"), log("owner", owner.as_str())],
attributes: vec![attr("action", "change_owner"), attr("owner", owner)],
..HandleResponse::default()
})
}

pub fn query<S: Storage, A: Api, Q: Querier>(
deps: &Extern<S, A, Q>,
_env: Env,
msg: QueryMsg,
) -> StdResult<Binary> {
match msg {
Expand All @@ -91,35 +97,37 @@ fn query_owner<S: Storage, A: Api, Q: Querier>(deps: &Extern<S, A, Q>) -> StdRes
#[cfg(test)]
mod tests {
use super::*;
use cosmwasm_std::testing::{mock_dependencies, mock_env};
use cosmwasm_std::{coins, from_binary, BankMsg, StdError};
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
use cosmwasm_std::{coins, from_binary, BankMsg};

#[test]
fn proper_initialization() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(1000, "earth"));
let env = mock_env();

let info = mock_info("creator", &coins(1000, "earth"));
// we can just call .unwrap() to assert this was a success
let res = init(&mut deps, env, msg).unwrap();
let res = init(&mut deps, env.clone(), info, msg).unwrap();
assert_eq!(0, res.messages.len());

// it worked, let's query the state
let res = query(&deps, QueryMsg::Owner {}).unwrap();
let res = query(&deps, env, QueryMsg::Owner {}).unwrap();
let value: OwnerResponse = from_binary(&res).unwrap();
assert_eq!("creator", value.owner.as_str());
}

#[test]
fn reflect() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(2, "token"));
let _res = init(&mut deps, env, msg).unwrap();
let info = mock_info("creator", &coins(1000, "earth"));
let env = mock_env();
let _res = init(&mut deps, env, info.clone(), msg).unwrap();

let env = mock_env("creator", &[]);
let env = mock_env();
let payload = vec![CosmosMsg::Bank(BankMsg::Send {
from_address: env.contract.address.clone(),
to_address: HumanAddr::from("friend"),
Expand All @@ -129,20 +137,22 @@ mod tests {
let msg = HandleMsg::ReflectMsg {
msgs: payload.clone(),
};
let res = handle(&mut deps, env, msg).unwrap();
let res = handle(&mut deps, env, info, msg).unwrap();
assert_eq!(payload, res.messages);
}

#[test]
fn reflect_requires_owner() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(2, "token"));
let _res = init(&mut deps, env, msg).unwrap();
let info = mock_info("creator", &coins(2, "token"));
let env = mock_env();
let _res = init(&mut deps, env, info.clone(), msg).unwrap();

// sender is not contract owner
let env = mock_env("someone", &[]);
let env = mock_env();
let info = mock_info("someone", &[]);
let payload = vec![CosmosMsg::Bank(BankMsg::Send {
from_address: env.contract.address.clone(),
to_address: HumanAddr::from("friend"),
Expand All @@ -152,45 +162,45 @@ mod tests {
msgs: payload.clone(),
};

let res = handle(&mut deps, env, msg);
let res = handle(&mut deps, env, info, msg);
match res {
Err(StdError::Unauthorized { .. }) => {}
Err(ContractError::Unauthorized { .. }) => {}
_ => panic!("Must return unauthorized error"),
}
}

#[test]
fn reflect_reject_empty_msgs() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(2, "token"));
let _res = init(&mut deps, env, msg).unwrap();
let env = mock_env();
let info = mock_info("creator", &coins(2, "token"));
let _res = init(&mut deps, env, info.clone(), msg).unwrap();

let env = mock_env("creator", &[]);
let env = mock_env();
let payload = vec![];

let msg = HandleMsg::ReflectMsg {
msgs: payload.clone(),
};
let res = handle(&mut deps, env, msg);
let res = handle(&mut deps, env, info, msg);
match res {
Err(StdError::GenericErr { msg, .. }) => {
assert_eq!(msg, "Must reflect at least one message")
}
Err(ContractError::NoReflectMsg {}) => {}
_ => panic!("Must return contract error"),
}
}

#[test]
fn reflect_multiple_messages() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(2, "token"));
let _res = init(&mut deps, env, msg).unwrap();
let env = mock_env();
let info = mock_info("creator", &coins(2, "token"));
let _res = init(&mut deps, env, info.clone(), msg).unwrap();

let env = mock_env("creator", &[]);
let env = mock_env();
let payload = vec![
CosmosMsg::Bank(BankMsg::Send {
from_address: env.contract.address.clone(),
Expand All @@ -207,49 +217,52 @@ mod tests {
let msg = HandleMsg::ReflectMsg {
msgs: payload.clone(),
};
let res = handle(&mut deps, env, msg).unwrap();
let res = handle(&mut deps, env, info, msg).unwrap();
assert_eq!(payload, res.messages);
}

#[test]
fn transfer() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(2, "token"));
let _res = init(&mut deps, env, msg).unwrap();
let env = mock_env();
let info = mock_info("creator", &coins(2, "token"));
let _res = init(&mut deps, env, info.clone(), msg).unwrap();

let env = mock_env("creator", &[]);
let env = mock_env();
let new_owner = HumanAddr::from("friend");
let msg = HandleMsg::ChangeOwner {
owner: new_owner.clone(),
};
let res = handle(&mut deps, env, msg).unwrap();
let res = handle(&mut deps, env.clone(), info, msg).unwrap();

// should change state
assert_eq!(0, res.messages.len());
let res = query(&deps, QueryMsg::Owner {}).unwrap();
let res = query(&deps, env, QueryMsg::Owner {}).unwrap();
let value: OwnerResponse = from_binary(&res).unwrap();
assert_eq!("friend", value.owner.as_str());
}

#[test]
fn transfer_requires_owner() {
let mut deps = mock_dependencies(20, &[]);
let mut deps = mock_dependencies(&[]);

let msg = InitMsg {};
let env = mock_env("creator", &coins(2, "token"));
let _res = init(&mut deps, env, msg).unwrap();
let info = mock_info("creator", &coins(2, "token"));
let env = mock_env();
let _res = init(&mut deps, env, info.clone(), msg).unwrap();

let env = mock_env("random", &[]);
let env = mock_env();
let info = mock_info("random", &[]);
let new_owner = HumanAddr::from("friend");
let msg = HandleMsg::ChangeOwner {
owner: new_owner.clone(),
};

let res = handle(&mut deps, env, msg);
let res = handle(&mut deps, env, info, msg);
match res {
Err(StdError::Unauthorized { .. }) => {}
Err(ContractError::Unauthorized { .. }) => {}
_ => panic!("Must return unauthorized error"),
}
}
Expand Down
Loading

0 comments on commit a9ca345

Please sign in to comment.