Struct Response

#[non_exhaustive]
pub struct Response<T = Empty> {
    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::new().add_attribute("action", "instantiate"))
}

Mutating:

use cosmwasm_std::Response;

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

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

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.

More info about events (and their attributes) can be found in Cosmos SDK docs.

events: Vec<Event>

Extra, custom events separate from the main wasm one. These will have wasm- prepended to the type.

More info about events can be found in Cosmos SDK docs.

data: Option<Binary>

The binary payload to include in the response.

Implementations

impl<T> Response<T>

pub fn new() -> Self

pub fn add_attribute( self, key: impl Into<String>, value: impl Into<String>, ) -> Self

Add an attribute included in the main wasm event.

For working with optional values or optional attributes, see add_attributes.

pub fn add_message(self, msg: impl Into<CosmosMsg<T>>) -> Self

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(self, msg: SubMsg<T>) -> Self

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(self, event: impl Into<Event>) -> Self

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 add_attributes<A: Into<Attribute>>( self, attrs: impl IntoIterator<Item = A>, ) -> Self

Bulk add attributes included in the main wasm event.

Anything that can be turned into an iterator and yields something that can be converted into an Attribute is accepted.

Examples

Adding a list of attributes using the pair notation for key and value:

use cosmwasm_std::Response;

let attrs = vec![
    ("action", "reaction"),
    ("answer", "42"),
    ("another", "attribute"),
];
let res: Response = Response::new().add_attributes(attrs.clone());
assert_eq!(res.attributes, attrs);

Adding an optional value as an optional attribute by turning it into a list of 0 or 1 elements:

use cosmwasm_std::{Attribute, Response};

// Some value
let value: Option<String> = Some("sarah".to_string());
let attribute: Option<Attribute> = value.map(|v| Attribute::new("winner", v));
let res: Response = Response::new().add_attributes(attribute);
assert_eq!(res.attributes, [Attribute {
    key: "winner".to_string(),
    value: "sarah".to_string(),
}]);

// No value
let value: Option<String> = None;
let attribute: Option<Attribute> = value.map(|v| Attribute::new("winner", v));
let res: Response = Response::new().add_attributes(attribute);
assert_eq!(res.attributes.len(), 0);

pub fn add_messages<M: Into<CosmosMsg<T>>>( self, msgs: impl IntoIterator<Item = M>, ) -> Self

Bulk add “fire and forget” messages to the list of messages to process.

Examples

use cosmwasm_std::{CosmosMsg, Response};

fn make_response_with_msgs(msgs: Vec<CosmosMsg>) -> Response {
    Response::new().add_messages(msgs)
}

pub fn add_submessages(self, msgs: impl IntoIterator<Item = SubMsg<T>>) -> Self

Bulk add explicit SubMsg structs to the list of messages to process.

Examples

use cosmwasm_std::{SubMsg, Response};

fn make_response_with_submsgs(msgs: Vec<SubMsg>) -> Response {
    Response::new().add_submessages(msgs)
}

pub fn add_events<E>(self, events: impl IntoIterator<Item = E>) -> Self

where E: Into<Event>,

Bulk add custom events to the response. These are separate from the main wasm event.

The wasm- prefix will be appended by the runtime to the provided types of events.

pub fn set_data(self, data: impl Into<Binary>) -> Self

Set the binary data included in the response.

pub fn change_custom<U>(self) -> Option<Response<U>>

Convert this Response<T> to a Response<U> with a different custom message type. This allows easier interactions between code written for a specific chain and code written for multiple chains. If this contains a CosmosMsg::Custom submessage, the function returns None.

Trait Implementations

impl<T: Clone> Clone for Response<T>

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>

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

Formats the value using the given formatter.

impl<T> Default for Response<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Response<T>

where 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>

fn schema_name() -> String

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &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 for Response<T>

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Response<T>

where 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: Eq> Eq for Response<T>

impl<T> StructuralPartialEq for Response<T>