Struct casper_contract_schema::Event

pub struct Event {
    pub name: String,
    pub ty: TypeName,
}

Event definition.

Fields

name: String

ty: TypeName

Implementations

impl Event

pub fn new(name: &str, ty: &str) -> Self

Creates a new event.

Examples found in repository

examples/dns.rs (line 118)

fn enum_example_schema() -> ContractSchema {
    ContractSchema {
        casper_contract_schema_version: 1,
        toolchain: String::from("rustc 1.73.0 (cc66ad468 2023-10-03)"),
        contract_name: String::from("DNS"),
        contract_version: String::from("0.1.3"),
        authors: vec![],
        repository: None,
        homepage: None,
        errors: vec![],
        types: vec![
            CustomType::Struct {
                name: TypeName::new("IP::IPv6"),
                description: None,
                members: vec![StructMember::new("ip", "", NamedCLType::ByteArray(16))],
            },
            CustomType::Struct {
                name: TypeName::new("IP::IPv6WithDescription"),
                description: None,
                members: vec![
                    StructMember::new("ip", "", NamedCLType::ByteArray(16)),
                    StructMember::new("description", "", NamedCLType::String),
                ],
            },
            CustomType::Enum {
                name: TypeName::new("IP"),
                description: Some(String::from("IP address")),
                variants: vec![
                    EnumVariant {
                        name: String::from("Unknown"),
                        description: None,
                        discriminant: 0,
                        ty: NamedCLType::Unit.into(),
                    },
                    EnumVariant {
                        name: String::from("IPv4"),
                        description: Some(String::from("IPv4 address")),
                        discriminant: 1,
                        ty: NamedCLType::ByteArray(4).into(),
                    },
                    EnumVariant {
                        name: String::from("IPv4WithDescription"),
                        description: Some(String::from("IPv4 address with description")),
                        discriminant: 2,
                        ty: NamedCLType::Tuple2([
                            Box::new(NamedCLType::ByteArray(4)),
                            Box::new(NamedCLType::String),
                        ])
                        .into(),
                    },
                    EnumVariant {
                        name: String::from("IPv6"),
                        description: Some(String::from("IPv6 address")),
                        discriminant: 3,
                        ty: NamedCLType::Custom("IP::IPv6".to_owned()).into(),
                    },
                    EnumVariant {
                        name: String::from("IPv6WithDescription"),
                        description: Some(String::from("IPv6 address with description")),
                        discriminant: 4,
                        ty: NamedCLType::Custom("IP::IPv6WithDescription".to_owned()).into(),
                    },
                ],
            },
            CustomType::Struct {
                name: TypeName::new("DNSRecord"),
                description: Some(String::from("DNS record")),
                members: vec![
                    StructMember::new("name", "Domain name", NamedCLType::String),
                    StructMember::new("ip", "", NamedCLType::Custom("IP".to_owned())),
                ],
            },
        ],
        entry_points: vec![
            Entrypoint {
                name: String::from("add_record"),
                description: None,
                is_mutable: true,
                arguments: vec![
                    Argument::new("name", "", NamedCLType::String),
                    Argument::new("ip", "", NamedCLType::Custom("IP".to_owned())),
                ],
                return_ty: NamedCLType::Unit.into(),
                is_contract_context: true,
                access: Access::Public,
            },
            Entrypoint {
                name: String::from("remove_record"),
                description: Some(String::from("Remove a DNS record")),
                is_mutable: true,
                arguments: vec![
                    Argument::new("name", "", NamedCLType::String),
                    Argument::new("ip", "", NamedCLType::Custom("IP".to_owned())),
                ],
                return_ty: NamedCLType::Unit.into(),
                is_contract_context: true,
                access: Access::Groups(vec![String::from("admin"), String::from("moderator")]),
            },
        ],
        events: vec![
            Event::new("event_RecordAdded", "DNSRecord"),
            Event::new("event_RecordRemoved", "DNSRecord"),
        ],
        call: None,
    }
}

examples/erc20.rs (line 134)

pub fn example_erc20_schema() -> ContractSchema {
    ContractSchema {
        casper_contract_schema_version: 1,
        toolchain: String::from("rustc 1.73.0 (cc66ad468 2023-10-03)"),
        contract_name: String::from("Erc20"),
        contract_version: String::from("0.1.0"),
        authors: vec![String::from("John Doe <john@doe.com>")],
        repository: Some(String::from(
            "https://github.com/casper-ecosystem/casper-contract-schema",
        )),
        homepage: Some(String::from("https://john.doe.com")),
        errors: vec![
            UserError {
                name: String::from("InsufficientFunds"),
                description: Some(String::from("Insufficient funds")),
                discriminant: 100u16,
            },
            UserError {
                name: String::from("InsufficientAllowance"),
                description: Some(String::from("Insufficient allowance")),
                discriminant: 101u16,
            },
        ],
        types: vec![
            CustomType::Struct {
                name: TypeName::new("Transfer"),
                description: Some(String::from("Transfer event")),
                members: vec![
                    StructMember::new(
                        "from",
                        "Sender of tokens.",
                        NamedCLType::Option(Box::new(NamedCLType::Key)),
                    ),
                    StructMember::new(
                        "to",
                        "Recipient of tokens.",
                        NamedCLType::Option(Box::new(NamedCLType::Key)),
                    ),
                    StructMember::new("value", "Transfered amount.", NamedCLType::U256),
                ],
            },
            CustomType::Struct {
                name: TypeName::new("Approval"),
                description: Some(String::from("Approval event")),
                members: vec![
                    StructMember::new("owner", "", NamedCLType::Option(Box::new(NamedCLType::Key))),
                    StructMember::new(
                        "spender",
                        "",
                        NamedCLType::Option(Box::new(NamedCLType::Key)),
                    ),
                    StructMember::new("value", "", NamedCLType::U256),
                ],
            },
        ],
        entry_points: vec![
            Entrypoint {
                name: String::from("transfer"),
                description: Some(String::from("Transfer tokens to another account")),
                is_mutable: true,
                arguments: vec![
                    Argument::new("recipient", "", NamedCLType::Key),
                    Argument::new("amount", "", NamedCLType::U256),
                ],
                return_ty: NamedCLType::Unit.into(),
                is_contract_context: true,
                access: Access::Public,
            },
            Entrypoint {
                name: String::from("transfer_from"),
                description: Some(String::from("Transfer tokens from one account to another")),
                is_mutable: true,
                arguments: vec![
                    Argument::new("owner", "", NamedCLType::Key),
                    Argument::new("recipient", "", NamedCLType::Key),
                    Argument::new("amount", "", NamedCLType::U256),
                ],
                return_ty: NamedCLType::Unit.into(),
                is_contract_context: true,
                access: Access::Public,
            },
            Entrypoint {
                name: String::from("approve"),
                description: Some(String::from(
                    "Approve spender to use tokens on behalf of the owner",
                )),
                is_mutable: true,
                arguments: vec![
                    Argument::new("spender", "", NamedCLType::Key),
                    Argument::new("amount", "", NamedCLType::U256),
                ],
                return_ty: NamedCLType::Unit.into(),
                is_contract_context: true,
                access: Access::Public,
            },
            Entrypoint {
                name: String::from("allowance"),
                description: Some(String::from(
                    "Check the amount of tokens that an owner allowed to a spender",
                )),
                is_mutable: false,
                arguments: vec![
                    Argument::new("owner", "", NamedCLType::Key),
                    Argument::new("spender", "", NamedCLType::Key),
                ],
                return_ty: NamedCLType::U256.into(),
                is_contract_context: true,
                access: Access::Public,
            },
            Entrypoint {
                name: String::from("balance_of"),
                description: Some(String::from(
                    "Check the amount of tokens owned by an account",
                )),
                is_mutable: false,
                arguments: vec![Argument::new("owner", "", NamedCLType::Key)],
                return_ty: NamedCLType::U256.into(),
                is_contract_context: true,
                access: Access::Public,
            },
            Entrypoint {
                name: String::from("total_supply"),
                description: Some(String::from("Check the total supply of tokens")),
                is_mutable: false,
                arguments: vec![],
                return_ty: NamedCLType::U256.into(),
                is_contract_context: true,
                access: Access::Public,
            },
        ],
        events: vec![
            Event::new("event_Transfer", "Transfer"),
            Event::new("event_Approval", "Approval"),
        ],
        call: Some(CallMethod::new(
            "erc20.wasm",
            "Fungible token",
            vec![
                Argument::new("name", "Name of the token", NamedCLType::String),
                Argument::new("symbol", "Symbol of the token", NamedCLType::String),
                Argument::new("decimals", "Number of decimals", NamedCLType::U8),
                Argument::new(
                    "initial_supply",
                    "Initial supply of tokens",
                    NamedCLType::U256,
                ),
            ],
        )),
    }
}

Trait Implementations

impl Debug for Event

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Event

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for Event

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 Ord for Event

fn cmp(&self, other: &Event) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Event

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

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

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

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

impl PartialOrd for Event

fn partial_cmp(&self, other: &Event) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Event

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 Event

impl StructuralPartialEq for Event