Enum WasmQuery

#[non_exhaustive]
pub enum WasmQuery {
    Smart {
        contract_addr: String,
        msg: Binary,
    },
    Raw {
        contract_addr: String,
        key: Binary,
    },
    ContractInfo {
        contract_addr: String,
    },
    CodeInfo {
        code_id: u64,
    },
    RawRange {
        contract_addr: String,
        start: Option<Binary>,
        end: Option<Binary>,
        limit: u16,
        order: Order,
    },
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Smart

this queries the public API of another contract at a known address (with known ABI) Return value is whatever the contract returns (caller should know), wrapped in a ContractResult that is JSON encoded.

Fields

contract_addr: String

msg: Binary

msg is the json-encoded QueryMsg struct

Raw

this queries the raw kv-store of the contract. returns the raw, unparsed data stored at that key, which may be an empty vector if not present

Fields

contract_addr: String

key: Binary

Key is the raw key used in the contracts Storage

ContractInfo

Returns a ContractInfoResponse with metadata on the contract from the runtime

Fields

contract_addr: String

CodeInfo

Returns a CodeInfoResponse with metadata of the code

Fields

code_id: u64

RawRange

Queries a range of keys from the storage of a (different) contract, returning a RawRangeResponse.

This is a low-level query that allows you to query the storage of another contract. Please keep in mind that the contract you are querying might change its storage layout using migrations, which could break your queries, so it is recommended to only use this for contracts you control.

Fields

contract_addr: String

The address of the contract to query

start: Option<Binary>

Inclusive start bound. This is the first key you would like to get data for.

If start is lexicographically greater than or equal to end, an empty range is described, mo matter of the order.

end: Option<Binary>

Exclusive end bound. This is the key after the last key you would like to get data for.

limit: u16

Maximum number of elements to return.

Make sure to set a reasonable limit to avoid running out of memory or into the deserialization limits of the VM. Also keep in mind that these limitations depend on the full JSON size of the response type.

order: Order

The order in which you want to receive the key-value pairs.

Implementations

impl WasmQuery

pub fn raw_range<'a, R, B>( contract_addr: impl Into<String>, range: R, limit: u16, order: Order, ) -> Self

where R: RangeBounds<&'a B>, B: ToByteVec + ?Sized + 'a,

Creates a new WasmQuery::RawRange from the given parameters.

This takes a RangeBounds to allow for specifying the range in a more idiomatic way.

Trait Implementations

impl Clone for WasmQuery

fn clone(&self) -> WasmQuery

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WasmQuery

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for WasmQuery

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<C: CustomQuery> From<WasmQuery> for QueryRequest<C>

fn from(msg: WasmQuery) -> Self

Converts to this type from the input type.

impl JsonSchema for WasmQuery

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 WasmQuery

fn eq(&self, other: &WasmQuery) -> bool

Tests for self and other values to be equal, and is used by ==.

const 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 Schemaifier for WasmQuery

fn visit_schema(visitor: &mut SchemaVisitor) -> DefinitionReference

fn id() -> Identifier

impl Serialize for WasmQuery

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for WasmQuery

impl StructuralPartialEq for WasmQuery