Struct cosmwasm_std::Response

pub struct Response<T = Empty> where
    T: Clone + Debug + PartialEq + JsonSchema,  {
    pub messages: Vec<SubMsg<T>>,
    pub attributes: Vec<Attribute>,
    pub events: Vec<Event>,
    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 {
        messages: vec![],
        attributes: vec![attr("action", "instantiate")],
        events: vec![],
        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

messages: Vec<SubMsg<T>>

Optional list of messages to pass. These will be executed in order. If the ReplyOn variant matches the result (Always, Success on Ok, Error on Err), the runtime will invoke this contract’s reply entry point after execution. Otherwise, they act like “fire and forget”. Use SubMsg::new to create messages with the older “fire and forget” semantics.

attributes: Vec<Attribute>

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

events: Vec<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
)

Add an attribute included in the main wasm event.

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

This creates a “fire and forget” message, by using SubMsg::new() to wrap it, and adds it to the list of messages to process.

pub fn add_submessage(&mut self, msg: SubMsg<T>)

This takes an explicit SubMsg (creates via eg. reply_on_error) and adds it to the list of messages to process.

pub fn add_event(&mut self, event: Event)

Adds an extra event to the response, separate from the main wasm event that is always created.

The wasm- prefix will be appended by the runtime to the provided type of event.

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.

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: 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.

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,