Enum levana_perpswap_cosmos::contracts::market::crank::CrankWorkInfo

pub enum CrankWorkInfo {
    CloseAllPositions {
        position: PositionId,
    },
    ResetLpBalances {},
    Liquifunding {
        position: PositionId,
    },
    Liquidation {
        position: PositionId,
        liquidation_reason: LiquidationReason,
    },
    DeferredExec {
        deferred_exec_id: DeferredExecId,
        target: DeferredExecTarget,
    },
    LimitOrder {
        order_id: OrderId,
    },
    Completed {},
}

What work is currently available for the crank.

Variants

CloseAllPositions

Closing all open positions

Fields

position: PositionId

Next position to be closed

ResetLpBalances

Resetting all LP balances to 0 after all liquidity is drained

Liquifunding

Liquifund a position

Fields

position: PositionId

Next position to be liquifunded

Liquidation

Liquidate a position.

Includes max gains, take profit, and stop loss.

Fields

position: PositionId

Position to liquidate

liquidation_reason: LiquidationReason

Reason for the liquidation

DeferredExec

Deferred execution (open/update/closed) can be executed.

Fields

deferred_exec_id: DeferredExecId

ID to be processed

target: DeferredExecTarget

Target of the action

LimitOrder

Limit order can be opened

Fields

order_id: OrderId

ID of the order to be opened

Completed

Finished all processing for a given price update

Implementations

impl CrankWorkInfo

pub fn receives_crank_rewards(&self) -> bool

Should a cranker receive rewards for performing this action?

We generally want to give out rewards for actions that are directly user initiated and will be receiving a crank fee paid into the system. Actions which are overall protocol maintenance without a specific user action may be unfunded. A simple “attack” we want to avoid is a cranker flooding the system with unnecessary price updates + cranks to continue making a profit off of “Completed” items.

Trait Implementations

impl Clone for CrankWorkInfo

fn clone(&self) -> CrankWorkInfo

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for CrankWorkInfo

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CrankWorkInfo

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CrankWorkInfo

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(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 PartialEq for CrankWorkInfo

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

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<Event> for CrankWorkInfo

type Error = Error

The type returned in the event of a conversion error.

fn try_from(evt: Event) -> Result<Self>

Performs the conversion.

impl StructuralPartialEq for CrankWorkInfo