Enum ExecuteMsg

pub enum ExecuteMsg {
    RemoveModule {
        module: ModuleInfo,
    },
    YankModule {
        module: ModuleInfo,
    },
    ProposeModules {
        modules: Vec<ModuleMapEntry>,
    },
    UpdateModuleConfiguration {
        module_name: String,
        namespace: Namespace,
        update_module: UpdateModule,
    },
    ApproveOrRejectModules {
        approves: Vec<ModuleInfo>,
        rejects: Vec<ModuleInfo>,
    },
    ClaimNamespace {
        account_id: AccountId,
        namespace: String,
    },
    RemoveNamespaces {
        namespaces: Vec<String>,
    },
    AddAccount {
        account_id: AccountId,
        account_base: AccountBase,
        namespace: Option<String>,
    },
    UpdateConfig {
        account_factory_address: Option<String>,
        allow_direct_module_registration_and_updates: Option<bool>,
        namespace_registration_fee: Option<Clearable<Coin>>,
    },
    UpdateOwnership(Action),
}

Version Control Execute Msg

Variants

RemoveModule

Remove some version of a module

Fields

module: ModuleInfo

YankModule

Yank a version of a module so that it may not be installed Only callable by Admin

Fields

module: ModuleInfo

ProposeModules

Propose new modules to the version registry Namespaces need to be claimed by the Account before proposing modules Once proposed, the modules need to be approved by the Admin via ExecuteMsg::ApproveOrRejectModules

Fields

modules: Vec<ModuleMapEntry>

UpdateModuleConfiguration

Sets the metadata configuration for a module. Only callable by namespace admin

Fields

module_name: String

namespace: Namespace

update_module: UpdateModule

ApproveOrRejectModules

Approve or reject modules This takes the modules in the pending_modules map and moves them to the registered_modules map or yanked_modules map

Fields

approves: Vec<ModuleInfo>

rejects: Vec<ModuleInfo>

ClaimNamespace

Claim namespaces

Fields

account_id: AccountId

namespace: String

RemoveNamespaces

Remove namespace claims Only admin or root user can call this

Fields

namespaces: Vec<String>

AddAccount

Register a new Account to the deployed Accounts. Claims namespace if provided.
Only Factory can call this

Fields

account_id: AccountId

account_base: AccountBase

namespace: Option<String>

UpdateConfig

Updates configuration of the VC contract

Fields

account_factory_address: Option<String>

Address of the account factory

allow_direct_module_registration_and_updates: Option<bool>

Whether the contract allows direct module registration

namespace_registration_fee: Option<Clearable<Coin>>

The fee charged when registering a namespace

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 Clone for ExecuteMsg

fn clone(&self) -> ExecuteMsg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ExecuteMsg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExecuteMsg

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for ExecuteMsg

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 ExecuteMsg

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for ExecuteMsg