Enum levana_perpswap_cosmos::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

• returns [cw2::ContractVersion]

Status

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

Fields

price: Option<PriceForQuery>

Price to be used as the current price

SpotPrice

• returns crate::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

Fields

timestamp: Option<Timestamp>

Timestamp when the price should be effective.

None means “give the most recent price.”

SpotPriceHistory

• returns SpotPriceHistoryResp

Gets a collection of historical spot prices

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

OraclePrice

• 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

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

Positions

• returns super::position::PositionsResp

Maps the given PositionIds into 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

LimitOrder

• returns LimitOrderResp

Returns the specified Limit Order

Fields

order_id: OrderId

Limit order ID to query

LimitOrders

• returns LimitOrdersResp

Returns the Limit Orders for the specified addr

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

ClosedPositionHistory

• returns ClosedPositionsResp

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

NftProxy

• 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

Fields

nft_msg: QueryMsg

NFT message to process

LiquidityTokenProxy

• 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

Fields

kind: LiquidityTokenKind

Whether to query LP or xLP tokens

msg: QueryMsg

Query to run

TradeHistorySummary

• returns TradeHistorySummary for a given wallet addr

Fields

addr: RawAddr

Which wallet’s history are we querying?

PositionActionHistory

• returns PositionActionHistoryResp

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

TraderActionHistory

Actions taken by a trader.

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

• returns TraderActionHistoryResp

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

LpActionHistory

• returns LpActionHistoryResp

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

LimitOrderHistory

• returns LimitOrderHistoryResp

Provides information on triggered limit orders.

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

LpInfo

• returns LpInfoResp

Provides the data needed by the earn page.

Fields

liquidity_provider: RawAddr

Which provider’s information are we querying?

ReferralStats

• returns ReferralStatsResp

Returns the referral rewards generated and received by this wallet.

Fields

addr: RawAddr

Which address to check

DeltaNeutralityFee

• returns DeltaNeutralityFeeResp

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

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

PriceWouldTrigger

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

• returns PriceWouldTriggerResp

Fields

price: PriceBaseInQuote

The new price of the base asset in terms of quote

ListDeferredExecs

Enumerate deferred execution work items for the given trader.

Always begins enumeration from the most recent.

• returns crate::contracts::market::deferred_execution::ListDeferredExecsResp

Fields

addr: RawAddr

Trader wallet address

start_after: Option<DeferredExecId>

Previously seen final ID.

limit: Option<u32>

How many items to request per batch.

GetDeferredExec

Get a single deferred execution item, if available.

• returns crate::contracts::market::deferred_execution::GetDeferredExecResp

Fields

id: DeferredExecId

ID

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