pub trait QueryPreimage {
    fn len(hash: &Hash) -> Option<u32>;
    fn fetch(hash: &Hash, len: Option<u32>) -> FetchResult;
    fn is_requested(hash: &Hash) -> bool;
    fn request(hash: &Hash);
    fn unrequest(hash: &Hash);

    fn hold<T>(bounded: &Bounded<T>) { ... }
    fn drop<T>(bounded: &Bounded<T>) { ... }
    fn have<T>(bounded: &Bounded<T>) -> bool { ... }
    fn pick<T>(hash: Hash, len: u32) -> Bounded<T> { ... }
    fn peek<T: Decode>(
        bounded: &Bounded<T>
    ) -> Result<(T, Option<u32>), DispatchError> { ... } fn realize<T: Decode>(
        bounded: &Bounded<T>
    ) -> Result<(T, Option<u32>), DispatchError> { ... } }
Expand description

A interface for looking up preimages from their hash on chain.

Required Methods

Returns whether a preimage exists for a given hash and if so its length.

Returns the preimage for a given hash. If given, len must be the size of the preimage.

Returns whether a preimage request exists for a given hash.

Request that someone report a preimage. Providers use this to optimise the economics for preimage reporting.

Cancel a previous preimage request.

Provided Methods

Request that the data required for decoding the given bounded value is made available.

No longer request that the data required for decoding the given bounded value is made available.

Check to see if all data required for the given bounded value is available for its decoding.

Create a Bounded instance based on the hash and len of the encoded value.

It also directly requests the given hash using Self::request.

This may not be peek-able or realize-able.

Convert the given bounded instance back into its original instance, also returning the exact size of its encoded form if it needed to be looked-up from a stored preimage).

NOTE: This does not remove any data needed for realization. If you will no longer use the bounded, call realize instead or call drop afterwards.

Convert the given bounded value back into its original instance. If successful, drop any data backing it. This will not break the realisability of independently created instances of Bounded which happen to have identical data.

Implementations on Foreign Types