Enum levana_perpswap_cosmos_msg::contracts::market::entry::QueryMsg

pub enum QueryMsg {
    Version {},
    Status {
        price: Option<PriceForQuery>,
    },
    SpotPrice {
        timestamp: Option<Timestamp>,
    },
    SpotPriceHistory {
        start_after: Option<Timestamp>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    OraclePrice {
        validate_age: bool,
    },
    Positions {
        position_ids: Vec<PositionId>,
        skip_calc_pending_fees: Option<bool>,
        fees: Option<PositionsQueryFeeApproach>,
        price: Option<PriceForQuery>,
    },
    LimitOrder {
        order_id: OrderId,
    },
    LimitOrders {
        owner: RawAddr,
        start_after: Option<OrderId>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    ClosedPositionHistory {
        owner: RawAddr,
        cursor: Option<ClosedPositionCursor>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    NftProxy {
        nft_msg: QueryMsg,
    },
    LiquidityTokenProxy {
        kind: LiquidityTokenKind,
        msg: QueryMsg,
    },
    TradeHistorySummary {
        addr: RawAddr,
    },
    PositionActionHistory {
        id: PositionId,
        start_after: Option<String>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    TraderActionHistory {
        owner: RawAddr,
        start_after: Option<String>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    LpActionHistory {
        addr: RawAddr,
        start_after: Option<String>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    LimitOrderHistory {
        addr: RawAddr,
        start_after: Option<String>,
        limit: Option<u32>,
        order: Option<OrderInMessage>,
    },
    LpInfo {
        liquidity_provider: RawAddr,
    },
    ReferralStats {
        addr: RawAddr,
    },
    DeltaNeutralityFee {
        notional_delta: Signed<Notional>,
        pos_delta_neutrality_fee_margin: Option<Collateral>,
    },
    PriceWouldTrigger {
        price: PriceBaseInQuote,
    },
    ListDeferredExecs {
        addr: RawAddr,
        start_after: Option<DeferredExecId>,
        limit: Option<u32>,
    },
    GetDeferredExec {
        id: DeferredExecId,
    },
}

Query messages on the market contract

Variants

Version

Fields

• returns [cw2::ContractVersion]

Status

Fields

price: Option<PriceForQuery>

Price to be used as the current price

Provides overall information about this market.

This is intended as catch-all for protocol wide information, both static (like market ID) and dynamic (like notional interest). The goal is to limit the total number of queries callers have to make to get relevant information.

• returns StatusResp

SpotPrice

Fields

timestamp: Option<Timestamp>

Timestamp when the price should be effective.

None means “give the most recent price.”

• returns shared::prelude::PricePoint

Gets the spot price, if no time is supplied, then it’s current This is the spot price as seen by the contract storage i.e. the price that was pushed via execution messages

SpotPriceHistory

Fields

start_after: Option<Timestamp>

Last timestamp we saw

limit: Option<u32>

How many prices to query

order: Option<OrderInMessage>

Order to sort by, if None then it will be descending

• returns SpotPriceHistoryResp

Gets a collection of historical spot prices

OraclePrice

Fields

validate_age: bool

If true then it will validate the publish_time age as though it were used to push a new spot_price update Otherwise, it just returns the oracle price as-is, even if it’s old

• returns OraclePriceResp

Gets the current price from the oracle (for markets configured with an oracle)

Also returns prices for each feed used to compose the final price

This may be more up-to-date than the spot price which was validated and pushed into the contract storage via execution messages

Positions

Fields

position_ids: Vec<PositionId>

Positions to query.

skip_calc_pending_fees: Option<bool>

Should we skip calculating pending fees?

This field is ignored if fees is set.

The default for this field is false. The behavior of this field is:

• true: the same as PositionsQueryFeeApproach::NoFees

• false: the same as PositionsQueryFeeApproach::AllFees (though see note on that variant, this default will likely change in the future).

It is recommended not to use this field going forward, and to instead use fees.

fees: Option<PositionsQueryFeeApproach>

How do we calculate fees for this position?

Any value here will override the skip_calc_pending_fees field.

price: Option<PriceForQuery>

Price to be used as the current price

• returns super::position::PositionsResp

Maps the given PositionIds into Positions

LimitOrder

Fields

order_id: OrderId

Limit order ID to query

• returns LimitOrderResp

Returns the specified Limit Order

LimitOrders

Fields

owner: RawAddr

Owner of limit orders

start_after: Option<OrderId>

Last limit order seen

limit: Option<u32>

Number of order to return

order: Option<OrderInMessage>

Whether to return ascending or descending

• returns LimitOrdersResp

Returns the Limit Orders for the specified addr

ClosedPositionHistory

Fields

owner: RawAddr

Owner of the positions to get history for

cursor: Option<ClosedPositionCursor>

Cursor to start from, for pagination

limit: Option<u32>

limit pagination

order: Option<OrderInMessage>

order is default Descending

• returns ClosedPositionsResp

NftProxy

Fields

nft_msg: QueryMsg

NFT message to process

• returns [cosmwasm_std::QueryResponse]

Nft proxy messages. Not meant to be called directly but rather for internal cross-contract calls

however, these are merely queries, and can be called by anyone and clients may take advantage of this to save query gas by calling the market directly

LiquidityTokenProxy

Fields

kind: LiquidityTokenKind

Whether to query LP or xLP tokens

msg: QueryMsg

Query to run

• returns [cosmwasm_std::QueryResponse]

Liquidity token cw20 proxy messages. Not meant to be called directly but rather for internal cross-contract calls

however, these are merely queries, and can be called by anyone and clients may take advantage of this to save query gas by calling the market directly

TradeHistorySummary

Fields

addr: RawAddr

Which wallet’s history are we querying?

• returns TradeHistorySummary for a given wallet addr

PositionActionHistory

Fields

id: PositionId

Which position’s history are we querying?

start_after: Option<String>

Last action ID we saw

limit: Option<u32>

How many actions to query

order: Option<OrderInMessage>

Order to sort by

• returns PositionActionHistoryResp

TraderActionHistory

Fields

owner: RawAddr

Which trader’s history are we querying?

start_after: Option<String>

Last action ID we saw

limit: Option<u32>

How many actions to query

order: Option<OrderInMessage>

Order to sort by

Actions taken by a trader.

Similar to Self::PositionActionHistory, but provides all details for an individual trader, not an individual position.

• returns TraderActionHistoryResp

LpActionHistory

Fields

addr: RawAddr

Which provider’s history are we querying?

start_after: Option<String>

Last action ID we saw

limit: Option<u32>

How many actions to query

order: Option<OrderInMessage>

Order to sort by

• returns LpActionHistoryResp

LimitOrderHistory

Fields

addr: RawAddr

Trader’s address for history we are querying

start_after: Option<String>

Last order ID we saw

limit: Option<u32>

How many orders to query

order: Option<OrderInMessage>

Order to sort the order IDs by

• returns LimitOrderHistoryResp

Provides information on triggered limit orders.

LpInfo

Fields

liquidity_provider: RawAddr

Which provider’s information are we querying?

• returns LpInfoResp

Provides the data needed by the earn page.

ReferralStats

Fields

addr: RawAddr

Which address to check

• returns ReferralStatsResp

Returns the referral rewards generated and received by this wallet.

DeltaNeutralityFee

Fields

notional_delta: Signed<Notional>

the amount of notional that would be changed

pos_delta_neutrality_fee_margin: Option<Collateral>

for real delta neutrality fees, this is calculated internally should only be supplied if querying the fee for close or update

• returns DeltaNeutralityFeeResp

Gets the delta neutrality fee at the current price, for a given change in terms of net notional

PriceWouldTrigger

Fields

price: PriceBaseInQuote

The new price of the base asset in terms of quote

Check if a price update would trigger a liquidation/take profit/etc.

• returns PriceWouldTriggerResp

ListDeferredExecs

Fields

addr: RawAddr

Trader wallet address

start_after: Option<DeferredExecId>

Previously seen final ID.

limit: Option<u32>

How many items to request per batch.

Enumerate deferred execution work items for the given trader.

Always begins enumeration from the most recent.

• returns [ListDeferredExecsResp]

GetDeferredExec

Fields

id: DeferredExecId

ID

Get a single deferred execution item, if available.

• returns [GetDeferredExecResp]

Trait Implementations

impl Clone for QueryMsg

fn clone(&self) -> QueryMsg

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for QueryMsg

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for QueryMsg

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for QueryMsg

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 QueryMsg

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

fn response_schemas_impl() -> BTreeMap<String, RootSchema>

fn response_schemas() -> Result<BTreeMap<String, RootSchema>, IntegrityError>

impl Serialize for QueryMsg

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 QueryMsg