Responses and Attributes in Cosmwasm

#[cfg_attr(not(feature = "library"), entry_point)]pub fn instantiate(    deps: DepsMut,    _env: Env,    info: MessageInfo,    msg: InstantiateMsg,) -> Result<Response, ContractError> {    let state = State {        count: msg.count,        owner: info.sender.clone(),    };    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;    STATE.save(deps.storage, &state)?;    Ok(Response::new()        .add_attribute("method", "instantiate")        .add_attribute("owner", info.sender)        .add_attribute("count", msg.count.to_string()))}

Ok(Response::new().add_attribute("action", "increment")        .add_message(BankMsg::Send { to_address: to.into_string(), amount: vec![Coin{denom, amount}] }))This message in the response is executed by the smart contract after the logic of the function is completed.

pub fn ibc_packet_receive(    deps: DepsMut,    _env: Env,    msg: IbcPacketReceiveMsg,) -> Result<IbcReceiveResponse, Never> {    // other parse code here...        let msg = Cw20ExecuteMsg::Transfer {        recipient,        amount: coin.amount,    };    let exec = WasmMsg::Execute {        contract_addr: coin.address,        msg: to_binary(&msg).unwrap(),        funds: vec![],    };    let sub_msg = SubMsg::reply_on_error(exec, SEND_TOKEN_ID);        // return submessage with pre-emptive success packet in the data field    IbcReceiveResponse::new()        .set_ack(ack_success())        .add_submessage(sub_msg)        .add_attributes(attributes)}

pub mod contract;mod error;pub mod helpers;pub mod msg;pub mod state;pub use crate::error::ContractError;

#[cfg(not(feature = "library"))]use cosmwasm_std::entry_point;use cosmwasm_std::{to_binary, Binary, Deps, DepsMut, Env, MessageInfo, Response, StdResult};use cw2::set_contract_version;use crate::error::ContractError;use crate::msg::{ExecuteMsg, GetCountResponse, InstantiateMsg, QueryMsg};use crate::state::{State, STATE};// version info for migration infoconst CONTRACT_NAME: &str = "crates.io:responses-attributes";const CONTRACT_VERSION: &str = env!("CARGO_PKG_VERSION");#[cfg_attr(not(feature = "library"), entry_point)]pub fn instantiate(    deps: DepsMut,    _env: Env,    info: MessageInfo,    msg: InstantiateMsg,) -> Result<Response, ContractError> {    let state = State {        count: msg.count,        owner: info.sender.clone(),    };    set_contract_version(deps.storage, CONTRACT_NAME, CONTRACT_VERSION)?;    STATE.save(deps.storage, &state)?;    Ok(Response::new()        .add_attribute("method", "instantiate")        .add_attribute("owner", info.sender)        .add_attribute("count", msg.count.to_string()))}#[cfg_attr(not(feature = "library"), entry_point)]pub fn execute(    deps: DepsMut,    _env: Env,    info: MessageInfo,    msg: ExecuteMsg,) -> Result<Response, ContractError> {    match msg {        ExecuteMsg::Increment {} => execute::increment(deps),        ExecuteMsg::Reset { count } => execute::reset(deps, info, count),    }}pub mod execute {    use super::*;    pub fn increment(deps: DepsMut) -> Result<Response, ContractError> {        STATE.update(deps.storage, |mut state| -> Result<_, ContractError> {            state.count += 1;            Ok(state)        })?;        Ok(Response::new().add_attribute("action", "increment"))    }    pub fn reset(deps: DepsMut, info: MessageInfo, count: i32) -> Result<Response, ContractError> {        STATE.update(deps.storage, |mut state| -> Result<_, ContractError> {            if info.sender != state.owner {                return Err(ContractError::Unauthorized {});            }            state.count = count;            Ok(state)        })?;        Ok(Response::new().add_attribute("action", "reset"))    }}#[cfg_attr(not(feature = "library"), entry_point)]pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {    match msg {        QueryMsg::GetCount {} => to_binary(&query::count(deps)?),    } }pub mod query {    use super::*;    pub fn count(deps: Deps) -> StdResult<GetCountResponse> {        let state = STATE.load(deps.storage)?;        Ok(GetCountResponse { count: state.count })    }}#[cfg(test)]mod tests {    use super::*;    use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};    use cosmwasm_std::{coins, from_binary};    #[test]    fn proper_initialization() {        let mut deps = mock_dependencies();        let msg = InstantiateMsg { count: 17 };        let info = mock_info("creator", &coins(1000, "earth"));        // we can just call .unwrap() to assert this was a success        let res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();        assert_eq!(0, res.messages.len());        // it worked, let's query the state        let res = query(deps.as_ref(), mock_env(), QueryMsg::GetCount {}).unwrap();        let value: GetCountResponse = from_binary(&res).unwrap();        assert_eq!(17, value.count);    }    #[test]    fn increment() {        let mut deps = mock_dependencies();        let msg = InstantiateMsg { count: 17 };        let info = mock_info("creator", &coins(2, "token"));        let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();        // beneficiary can release it        let info = mock_info("anyone", &coins(2, "token"));        let msg = ExecuteMsg::Increment {};        let _res = execute(deps.as_mut(), mock_env(), info, msg).unwrap();        // should increase counter by 1        let res = query(deps.as_ref(), mock_env(), QueryMsg::GetCount {}).unwrap();        let value: GetCountResponse = from_binary(&res).unwrap();        assert_eq!(18, value.count);    }    #[test]    fn reset() {        let mut deps = mock_dependencies();        let msg = InstantiateMsg { count: 17 };        let info = mock_info("creator", &coins(2, "token"));        let _res = instantiate(deps.as_mut(), mock_env(), info, msg).unwrap();        // beneficiary can release it        let unauth_info = mock_info("anyone", &coins(2, "token"));        let msg = ExecuteMsg::Reset { count: 5 };        let res = execute(deps.as_mut(), mock_env(), unauth_info, msg);        match res {            Err(ContractError::Unauthorized {}) => {}            _ => panic!("Must return unauthorized error"),        }        // only the original creator can reset the counter        let auth_info = mock_info("creator", &coins(2, "token"));        let msg = ExecuteMsg::Reset { count: 5 };        let _res = execute(deps.as_mut(), mock_env(), auth_info, msg).unwrap();        // should now be 5        let res = query(deps.as_ref(), mock_env(), QueryMsg::GetCount {}).unwrap();        let value: GetCountResponse = from_binary(&res).unwrap();        assert_eq!(5, value.count);    }}

use cosmwasm_schema::{cw_serde, QueryResponses};#[cw_serde]pub struct InstantiateMsg {    pub count: i32,}#[cw_serde]pub enum ExecuteMsg {    Increment {},    Reset { count: i32 },}#[cw_serde]#[derive(QueryResponses)]pub enum QueryMsg {    // GetCount returns the current count as a json-encoded number    #[returns(GetCountResponse)]    GetCount {},}// We define a custom struct for each query response#[cw_serde]pub struct GetCountResponse {    pub count: i32,}

use cosmwasm_std::StdError;use thiserror::Error;#[derive(Error, Debug)]pub enum ContractError {    #[error("{0}")]    Std(#[from] StdError),    #[error("Unauthorized")]    Unauthorized {},    // Add any other custom errors you like here.    // Look at https://docs.rs/thiserror/1.0.21/thiserror/ for details.}

use schemars::JsonSchema;use serde::{Deserialize, Serialize};use cosmwasm_std::Addr;use cw_storage_plus::Item;#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]pub struct State {    pub count: i32,    pub owner: Addr,}pub const STATE: Item<State> = Item::new("state");

use schemars::JsonSchema;use serde::{Deserialize, Serialize};use cosmwasm_std::{    to_binary, Addr, CosmosMsg, CustomQuery, Querier, QuerierWrapper, StdResult, WasmMsg, WasmQuery,};use crate::msg::{ExecuteMsg, GetCountResponse, QueryMsg};/// CwTemplateContract is a wrapper around Addr that provides a lot of helpers/// for working with this.#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, JsonSchema)]pub struct CwTemplateContract(pub Addr);impl CwTemplateContract {    pub fn addr(&self) -> Addr {        self.0.clone()    }    pub fn call<T: Into<ExecuteMsg>>(&self, msg: T) -> StdResult<CosmosMsg> {        let msg = to_binary(&msg.into())?;        Ok(WasmMsg::Execute {            contract_addr: self.addr().into(),            msg,            funds: vec![],        }        .into())    }    /// Get Count    pub fn count<Q, T, CQ>(&self, querier: &Q) -> StdResult<GetCountResponse>    where        Q: Querier,        T: Into<String>,        CQ: CustomQuery,    {        let msg = QueryMsg::GetCount {};        let query = WasmQuery::Smart {            contract_addr: self.addr().into(),            msg: to_binary(&msg)?,        }        .into();        let res: GetCountResponse = QuerierWrapper::<CQ>::new(querier).query(&query)?;        Ok(res)    }}