Struct DocumentHavingEntries 

pub struct DocumentHavingEntries {
    pub entries: Vec<RankedEntry>,
}

Verified having-range (GROUP BY … HAVING <aggregate> <op> <value> LIMIT n) result types. DocumentHavingEntries carries one entry per matching group in axis order; verify_having_range_proof is the tenderdash-composition wrapper that binds the proof’s reconstructed root hash to the signed app hash and returns the verified entry list — including its completeness: an in-range group the node omitted fails verification. One page of a GROUP BY … HAVING <aggregate> <op> <value> LIMIT n query: the groups whose aggregate falls inside the bound.

Entry order is axis order in the walk direction — ascending by default, descending when the request ordered by the aggregate descending. Callers must not re-sort; ties (groups with equal aggregates) come back in group-key order in the direction of the walk, same as on the ranked surface.

Fewer than n entries means fewer groups matched — not an error. Exactly n entries may mean the match set was cut at the limit; nothing in the page marks the cut. Tightening the bound past the last aggregate value seen continues past distinct values only — a cut inside a tie (several groups sharing the boundary aggregate) cannot be continued, so size the limit above the widest expected tie.

Entry semantics (RankedEntry) are identical to the ranked surface’s, including the fixed-point average scaling and the exact-on-the-proved-path-only caveat.

Fields

entries: Vec<RankedEntry>

The matching groups, in axis order in the walk direction.

Implementations

impl DocumentHavingEntries

pub fn from_verified(entries: Vec<RankedEntry>) -> Self

Build a DocumentHavingEntries from the verifier-side entry list — the shape rs-drive’s merk-level verifier returns.

pub fn from_unproved_response( response: &GetDocumentsResponse, ) -> Result<(Self, ResponseMetadata), Error>

Decode the unproven having-range payload of a getDocuments response — the ResultData.ranked variant a node returns for a having-range request sent with prove = false. (The wire reuses the ranked entries message; a having page leaves its skipped field unset, and this decoder ignores it either way, because a value-bounded page has no rank base for it to describe.)

Order is preserved verbatim. This is a plain wire decode with no cryptographic guarantee whatsoever — and unlike the ranked surface the missing guarantee here includes completeness: an unproven page is free to omit matching groups, which for a spam-resistance query is precisely the interesting attack. Prefer verify_having_range_proof (via rs-sdk’s DocumentHavingEntries::fetch) unless you deliberately trust the node.

Errors

• Error::EmptyVersion when the response carries no version.
• Error::ResponseDecodeError when the response is a V0 response, carries a proof rather than data, carries a non-ranked ResultData variant, or an entry’s value oneof is unset / out of domain.

Trait Implementations

impl Clone for DocumentHavingEntries

fn clone(&self) -> DocumentHavingEntries

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DocumentHavingEntries

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

Formats the value using the given formatter.

impl Default for DocumentHavingEntries

fn default() -> DocumentHavingEntries

Returns the “default value” for a type.

impl Eq for DocumentHavingEntries

impl<'dq, Q> FromProof<Q> for DocumentHavingEntries

where Q: TryInto<DriveDocumentQuery<'dq>> + Clone + 'dq, Q::Error: Display,

Reject the generic FromProof entry point for DocumentHavingEntries — same guard rail, same rationale as the crate::DocumentRankedEntries blanket impl: the generic FromProof<Q: TryInto<DriveDocumentQuery>> path carries neither the bounds nor the covering index, so it errors out explicitly rather than verifying the wrong thing.

type Request = Q

Request type for which this trait is implemented.

type Response = GetDocumentsResponse

Response type for which this trait is implemented.

fn maybe_from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( _request: I, _response: O, _network: Network, _platform_version: &PlatformVersion, _provider: &'a dyn ContextProvider, ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error>

where Self: 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn maybe_from_proof<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Option<Self>, Error>

where Self: Sized + 'a,

Parse and verify the received proof and retrieve the requested object, if any.

fn from_proof<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<Self, Error>

where Self: Sized + 'a,

Retrieve the requested object from the proof.

fn from_proof_with_metadata<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata), Error>

where Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

fn from_proof_with_metadata_and_proof<'a, I: Into<Self::Request>, O: Into<Self::Response>>( request: I, response: O, network: Network, platform_version: &PlatformVersion, provider: &'a dyn ContextProvider, ) -> Result<(Self, ResponseMetadata, Proof), Error>

where Self: Sized + 'a,

Retrieve the requested object from the proof with metadata.

impl PartialEq for DocumentHavingEntries

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for DocumentHavingEntries