Enum ExecuteMsg 

pub enum ExecuteMsg<T, E> {
    TransferNft {
        recipient: String,
        token_id: String,
    },
    SendNft {
        contract: String,
        token_id: String,
        msg: Binary,
    },
    Approve {
        spender: String,
        token_id: String,
        expires: Option<Expiration>,
    },
    Revoke {
        spender: String,
        token_id: String,
    },
    ApproveAll {
        operator: String,
        expires: Option<Expiration>,
    },
    RevokeAll {
        operator: String,
    },
    Mint {
        token_id: String,
        owner: String,
        token_uri: Option<String>,
        extension: T,
    },
    Burn {
        token_id: String,
    },
    Extension {
        msg: E,
    },
    UpdateCollectionInfo {
        collection_info: UpdateCollectionInfoMsg<RoyaltyInfoResponse>,
    },
    UpdateStartTradingTime(Option<Timestamp>),
    FreezeCollectionInfo,
    UpdateOwnership(Action),
}

Variants

TransferNft

Transfer is a base message to move a token to another account without triggering actions

Fields

recipient: String

token_id: String

SendNft

Send is a base message to transfer a token to a contract and trigger an action on the receiving contract.

Fields

contract: String

token_id: String

msg: Binary

Approve

Allows operator to transfer / send the token from the owner’s account. If expiration is set, then this allowance has a time/height limit

Fields

spender: String

token_id: String

expires: Option<Expiration>

Revoke

Remove previously granted Approval

Fields

spender: String

token_id: String

ApproveAll

Allows operator to transfer / send any token from the owner’s account. If expiration is set, then this allowance has a time/height limit

Fields

operator: String

expires: Option<Expiration>

RevokeAll

Remove previously granted ApproveAll permission

Fields

operator: String

Mint

Mint a new NFT, can only be called by the contract minter

Fields

token_id: String

Unique ID of the NFT

owner: String

The owner of the newly minter NFT

token_uri: Option<String>

Universal resource identifier for this NFT Should point to a JSON file that conforms to the ERC721 Metadata JSON Schema

extension: T

Any custom extension used by this contract

Burn

Burn an NFT the sender has access to

Fields

token_id: String

Extension

Extension msg

Fields

msg: E

UpdateCollectionInfo

Update specific collection info fields

Fields

collection_info: UpdateCollectionInfoMsg<RoyaltyInfoResponse>

UpdateStartTradingTime(Option<Timestamp>)

Called by the minter to update trading start time

FreezeCollectionInfo

UpdateOwnership(Action)

Update the contract’s ownership. The action to be provided can be either to propose transferring ownership to an account, accept a pending ownership transfer, or renounce the ownership permanently.

Trait Implementations

impl<T: Clone, E: Clone> Clone for ExecuteMsg<T, E>

fn clone(&self) -> ExecuteMsg<T, E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, E: Debug> Debug for ExecuteMsg<T, E>

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

Formats the value using the given formatter.

impl<'de, T, E> Deserialize<'de> for ExecuteMsg<T, E>

where T: Deserialize<'de>, E: 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, E: JsonSchema> JsonSchema for ExecuteMsg<T, E>

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, E: PartialEq> PartialEq for ExecuteMsg<T, E>

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

where T: Serialize, E: 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, E> StructuralPartialEq for ExecuteMsg<T, E>