Struct cosmwasm_std::Response

pub struct Response<T = Empty> where
    T: Clone + Debug + PartialEq + JsonSchema,  {
    pub submessages: Vec<SubMsg<T>>,
    pub messages: Vec<CosmosMsg<T>>,
    pub attributes: Vec<Attribute>,
    pub data: Option<Binary>,
}

A response of a contract entry point, such as instantiate, execute or migrate.

This type can be constructed directly at the end of the call. Alternatively a mutable response instance can be created early in the contract’s logic and incrementally be updated.

Examples

Direct:

use cosmwasm_std::{attr, Response, StdResult};

pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    _info: MessageInfo,
    msg: InstantiateMsg,
) -> StdResult<Response> {
    // ...

    Ok(Response {
        submessages: vec![],
        messages: vec![],
        attributes: vec![attr("action", "instantiate")],
        data: None,
    })
}

Mutating:

use cosmwasm_std::Response;

pub fn instantiate(
    deps: DepsMut,
    _env: Env,
    info: MessageInfo,
    msg: InstantiateMsg,
) -> Result<Response, MyError> {
    let mut response = Response::new();
    // ...
    response.add_attribute("Let the", "hacking begin");
    // ...
    response.add_message(BankMsg::Send {
        to_address: String::from("recipient"),
        amount: coins(128, "uint"),
    });
    response.add_attribute("foo", "bar");
    // ...
    response.set_data(Binary::from(b"the result data"));
    Ok(response)
}

Fields

submessages: Vec<SubMsg<T>>

Optional list of “subcalls” to make. These will be executed in order (and this contract’s subcall_response entry point invoked) before any of the “fire and forget” messages get executed.

messages: Vec<CosmosMsg<T>>

After any submessages are processed, these are all dispatched in the host blockchain. If they all succeed, then the transaction is committed. If any fail, then the transaction and any local contract state changes are reverted.

attributes: Vec<Attribute>

The attributes that will be emitted as part of a “wasm” event

data: Option<Binary>

Implementations

impl<T> Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

pub fn new() -> Self

pub fn add_attribute<K: Into<String>, V: Into<String>>(
    &mut self,
    key: K,
    value: V
)

pub fn add_message<U: Into<CosmosMsg<T>>>(&mut self, msg: U)

pub fn add_submessage<U: Into<CosmosMsg<T>>>(
    &mut self,
    id: u64,
    msg: U,
    gas_limit: Option<u64>,
    reply_on: ReplyOn
)

pub fn set_data<U: Into<Binary>>(&mut self, data: U)

Trait Implementations

impl<T: Clone> Clone for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

fn clone(&self) -> Response<T>

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T> Default for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema,
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> From<Context<T>> for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

fn from(ctx: Context<T>) -> Self

Performs the conversion.

impl<T: JsonSchema> JsonSchema for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

fn schema_name() -> String

The name of the generated JSON Schema.

fn json_schema(gen: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

pub fn is_referenceable() -> bool

Whether JSON Schemas generated for this type should be re-used where possible using the $ref keyword.

impl<T: PartialEq> PartialEq<Response<T>> for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema, 

fn eq(&self, other: &Response<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Response<T>) -> bool

This method tests for !=.

impl<T> Serialize for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema,
    T: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for Response<T> where
    T: Clone + Debug + PartialEq + JsonSchema,