Enum cosmwasm_std::StdAck

pub enum StdAck {
    Success(Binary),
    Error(String),
}

This is a standard IBC acknowledgement type. IBC application are free to use any acknowledgement format they want. However, for compatibility purposes it is recommended to use this.

The original proto definition can be found at https://github.com/cosmos/cosmos-sdk/blob/v0.42.0/proto/ibc/core/channel/v1/channel.proto#L141-L147 and https://github.com/cosmos/ibc/tree/ed849c7bac/spec/core/ics-004-channel-and-packet-semantics#acknowledgement-envelope.

In contrast to the original idea, ICS-20 and CosmWasm IBC protocols use JSON instead of a protobuf serialization.

For compatibility, we use the field name “result” for the success case in JSON. However, all Rust APIs use the term “success” for clarity and discriminability from Result.

If ibc_receive_packet returns Err(), then x/wasm runtime will rollback the state and return an error message in this format.

Examples

For your convenience, there are success and error constructors.

use cosmwasm_std::StdAck;

let ack1 = StdAck::success(b"\x01"); // 0x01 is a FungibleTokenPacketSuccess from ICS-20.
assert!(ack1.is_success());

let ack2 = StdAck::error("kaputt"); // Some free text error message
assert!(ack2.is_error());

Variants

Success(Binary)

Error(String)

Implementations

impl StdAck

pub fn success(data: impl Into<Binary>) -> Self

Creates a success ack with the given data

pub fn error(err: impl Into<String>) -> Self

Creates an error ack

pub const fn is_success(&self) -> bool

pub const fn is_error(&self) -> bool

pub fn to_binary(&self) -> Binary

Serialized the ack to binary using JSON. This used for setting the acknowledgement field in IbcReceiveResponse.

Examples

Show how the acknowledgement looks on the write:

let ack1 = StdAck::success(b"\x01"); // 0x01 is a FungibleTokenPacketSuccess from ICS-20.
assert_eq!(ack1.to_binary(), br#"{"result":"AQ=="}"#);

let ack2 = StdAck::error("kaputt"); // Some free text error message
assert_eq!(ack2.to_binary(), br#"{"error":"kaputt"}"#);

Set acknowledgement field in IbcReceiveResponse:

use cosmwasm_std::{StdAck, IbcReceiveResponse};

let ack = StdAck::success(b"\x01"); // 0x01 is a FungibleTokenPacketSuccess from ICS-20.

let res: IbcReceiveResponse = IbcReceiveResponse::new().set_ack(ack.to_binary());
let res: IbcReceiveResponse = IbcReceiveResponse::new().set_ack(ack); // Does the same but consumes the instance

pub fn unwrap(self) -> Binary

pub fn unwrap_err(self) -> String

Trait Implementations

impl Clone for StdAck

fn clone(&self) -> StdAck

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StdAck

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for StdAck

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<StdAck> for Binary

fn from(original: StdAck) -> Binary

Converts to this type from the input type.

impl JsonSchema for StdAck

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(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 PartialEq for StdAck

fn eq(&self, other: &StdAck) -> 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 Serialize for StdAck

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for StdAck

impl StructuralPartialEq for StdAck