Enum ExecuteMsg

pub enum ExecuteMsg {
    SetVault {
        vault: String,
        whitelisted: bool,
    },
    SetWithdrawalLockPeriod(Uint64),
    TransferOwnership {
        new_owner: String,
    },
    RequestSlashing(RequestSlashingPayload),
    LockSlashing(SlashingRequestId),
    CancelSlashing(SlashingRequestId),
    FinalizeSlashing(SlashingRequestId),
}

Variants

SetVault

ExecuteMsg SetVault the vault contract in the router and whitelist (true/false) it. Only the owner can call this message.

Fields

vault: String

whitelisted: bool

SetWithdrawalLockPeriod(Uint64)

ExecuteMsg SetWithdrawalLockPeriod the lock period for withdrawal. Only the owner can call this message.

TransferOwnership

ExecuteMsg TransferOwnership See bvs_library::ownership::transfer_ownership for more information on this field

Fields

new_owner: String

RequestSlashing(RequestSlashingPayload)

ExecuteMsg RequestSlashing initiates a slashing request against an active operator of the service (info.sender).

This ExecuteMsg allows a registered service to request a slash of an operator’s staked tokens as a penalty for violations or non-compliance. The slashing request must meet several criteria:

• The service must be actively registered with the operator at the specified timestamp
• The slashing amount (in bips) must not exceed the max_slashing_bips set by the service
• The operator must have opted in to slashing at the specified timestamp
• The timestamp must be within the allowable slashing window (not too old or in the future)
• The service must not have another active slashing request against the same operator
• The reason provided in metadata must not exceed the maximum allowed length

When successful, this creates a slashing request with an expiry time based on the resolution_window parameter and returns a unique slashing request ID.

Returns

On success, returns events with a data field set as RequestSlashingResponse containing the generated slashing request ID.

LockSlashing(SlashingRequestId)

ExecuteMsg LockSlashing initiates the movement of slashed collateral from vaults to the router which will later be finalized and handle according to the service slashing rules.

CancelSlashing(SlashingRequestId)

ExecuteMsg CancelSlashing cancels a resolved slashing request.

The service (slash initiator) should cancel the slashing process if the operator has resolved the issue. The definition of “resolved” is up to the service to define.

FinalizeSlashing(SlashingRequestId)

ExecuteMsg FinalizeSlashing moves the slashed collateral from the router to the destination specified in the slashing parameters that were agreed upon by the service and operator.

This is the final step in the slashing process and should only be called after the request has been locked, and the guardrail proposal has been voted on and passed.

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

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

Formats the value using the given formatter.

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 TestingContract<InstantiateMsg, ExecuteMsg, QueryMsg> for VaultRouterContract

fn wrapper() -> Box<dyn Contract<Empty>>

fn default_init(app: &mut App, _env: &Env) -> InstantiateMsg

fn new(app: &mut App, env: &Env, msg: Option<InstantiateMsg>) -> Self

fn addr(&self) -> &Addr

fn store_code(app: &mut App) -> u64

fn instantiate(app: &mut App, code_id: u64, label: &str, msg: &IM) -> Addr

fn set_contract_addr(app: &mut App, label: &str, addr: &Addr)

Set the contract address in the storage for the given label. Using the storage system for easy orchestration of contract addresses for testing.

fn get_contract_addr(app: &App, label: &str) -> Addr

Get the contract address in the storage for the given label.

fn execute( &self, app: &mut App, sender: &Addr, msg: &EM, ) -> Result<AppResponse, Error>

fn execute_with_funds( &self, app: &mut App, sender: &Addr, msg: &EM, funds: Vec<Coin>, ) -> Result<AppResponse, Error>

fn query<T>(&self, app: &App, msg: &QM) -> Result<T, StdError>

where T: DeserializeOwned,

fn migrate( &self, app: &mut App, sender: &Addr, msg: &MM, ) -> Result<AppResponse, Error>

impl StructuralPartialEq for ExecuteMsg