Enum SlashMsg

pub enum SlashMsg {
    AddSlasher {
        addr: String,
    },
    RemoveSlasher {
        addr: String,
    },
    Slash {
        addr: String,
        portion: Decimal,
    },
}

A common (sort of) interface for adding/removing slashers and slashing. This type exists so that contracts have an easy way of serializing these messages and using something like encode_raw_msg.

Examples

use tg4::Tg4Contract;
use tg_utils::SlashMsg;
use cosmwasm_std::{to_binary, Addr, Response};

let tg_contract = Tg4Contract::new(Addr::unchecked("some_contract"));

let slash_msg = to_binary(&SlashMsg::AddSlasher {
    addr: "some_other_contract".to_string(),
}).unwrap();

let res = Response::new()
    .add_submessage(tg_contract.encode_raw_msg(slash_msg).unwrap());

Variants

AddSlasher

Adds slasher for contract if there are enough slasher_preauths left

Fields

addr: String

RemoveSlasher

Removes slasher for contract

Fields

addr: String

Slash

Slash engagement points from address

Fields

addr: String

portion: Decimal

Trait Implementations

impl Clone for SlashMsg

fn clone(&self) -> SlashMsg

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SlashMsg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for SlashMsg

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for SlashMsg

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 PartialEq for SlashMsg

fn eq(&self, other: &SlashMsg) -> bool

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

const 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 SlashMsg

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 SlashMsg

impl StructuralPartialEq for SlashMsg