dashpay · QuantumExplorer · Aug 31, 2026 · Aug 31, 2026 · Aug 31, 2026 · Aug 31, 2026
@@ -52,7 +52,7 @@ pub(super) fn platform_version() -> &'static PlatformVersion {
     PlatformVersion::latest()
 }
 
-fn setup_likes() -> (Drive, DataContract) {
+pub(super) fn setup_likes() -> (Drive, DataContract) {
     let drive = setup_drive_with_initial_state_structure(None);
     let pv = platform_version();
     let contract = json_document_to_contract(

@@ -26,6 +26,7 @@
 //!   this file and is declared with `#[path]` so it can reuse that
 //!   suite's fixture and assertion helpers.
 
+mod chained_query_e2e_tests;
 mod countable_e2e_tests;
 mod index_only_e2e_tests;
 mod noncounted_sibling_e2e_tests;

@@ -4,6 +4,7 @@
 //!
 
 mod fetch_document_history_query;
+mod query_chained_documents;
 /// query of the vote state
 pub mod query_contested_documents_vote_state;
 mod query_documents;
@@ -12,6 +13,7 @@ mod query_documents_with_flags;
 /// query of the contested documents in their storage
 pub mod query_contested_documents_storage;
 
+pub use query_chained_documents::*;
 pub use query_documents::*;
 pub use query_documents_with_flags::*;
 

@@ -0,0 +1,73 @@
+mod v0;
+
+use crate::drive::Drive;
+use crate::error::drive::DriveError;
+use crate::error::Error;
+use crate::query::drive_chained_document_query::DriveChainedDocumentQuery;
+use dpp::block::epoch::Epoch;
+use dpp::document::Document;
+use dpp::version::PlatformVersion;
+use grovedb::TransactionArg;
+
+pub use v0::QueryChainedDocumentsOutcomeV0;
+
+impl Drive {
+    /// Executes a chained document query (provable semi-join) without
+    /// proofs and returns the materialized halves plus the processing
+    /// cost (when an epoch is given).
+    pub fn query_chained_documents(
+        &self,
+        query: &DriveChainedDocumentQuery,
+        epoch: Option<&Epoch>,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<QueryChainedDocumentsOutcomeV0, Error> {
+        match platform_version
+            .drive
+            .methods
+            .document
+            .query
+            .query_chained_documents
+        {
+            0 => self.query_chained_documents_v0(query, epoch, transaction, platform_version),
+            version => Err(Error::Drive(DriveError::UnknownVersionMismatch {
+                method: "query_chained_documents".to_string(),
+                known_versions: vec![0],
+                received: version,
+            })),
+        }
+    }
+
+    /// Executes a chained document query AND generates its single
+    /// merged proof (the limited inner page and the derived outer
+    /// by-ids fetch merged by `prove_query_many` — one proof, one root
+    /// by construction). Grovedb proves committed state only, so the
+    /// materialize/prove sequence is bracketed by root-hash reads and
+    /// retried when a block commit interleaves — see
+    /// [`DriveChainedDocumentQuery::execute_with_proof_internal`].
+    /// Shares the `query_chained_documents` version slot with the
+    /// no-proof path (one surface, one version).
+    /// Returns the merged proof plus the materialized INNER
+    /// projections (join values / hint / cursor derive from them); the
+    /// outer half is covered by the proof and not materialized.
+    pub fn query_chained_documents_with_proof(
+        &self,
+        query: &DriveChainedDocumentQuery,
+        platform_version: &PlatformVersion,
+    ) -> Result<(Vec<u8>, Vec<Document>), Error> {
+        match platform_version
+            .drive
+            .methods
+            .document
+            .query
+            .query_chained_documents
+        {
+            0 => self.query_chained_documents_with_proof_v0(query, platform_version),
+            version => Err(Error::Drive(DriveError::UnknownVersionMismatch {
+                method: "query_chained_documents_with_proof".to_string(),
+                known_versions: vec![0],
+                received: version,
+            })),
+        }
+    }
+}
@@ -0,0 +1,62 @@
+use crate::drive::Drive;
+use crate::error::Error;
+use crate::fees::op::LowLevelDriveOperation;
+use crate::query::drive_chained_document_query::{
+    ChainedDocumentsResult, DriveChainedDocumentQuery,
+};
+use dpp::block::epoch::Epoch;
+use dpp::version::PlatformVersion;
+use grovedb::TransactionArg;
+
+/// The outcome of a chained document query: the materialized halves and
+/// the processing cost.
+#[derive(Debug, Default)]
+pub struct QueryChainedDocumentsOutcomeV0 {
+    /// The materialized inner projections and outer documents.
+    pub result: ChainedDocumentsResult,
+    /// The processing cost, when an epoch was given.
+    pub cost: u64,
+}
+
+impl Drive {
+    #[inline(always)]
+    pub(super) fn query_chained_documents_v0(
+        &self,
+        query: &DriveChainedDocumentQuery,
+        epoch: Option<&Epoch>,
+        transaction: TransactionArg,
+        platform_version: &PlatformVersion,
+    ) -> Result<QueryChainedDocumentsOutcomeV0, Error> {
+        let mut drive_operations: Vec<LowLevelDriveOperation> = vec![];
+        let result = query.execute_no_proof_internal(
+            self,
+            transaction,
+            &mut drive_operations,
+            platform_version,
+        )?;
+        let cost = if let Some(epoch) = epoch {
+            Drive::calculate_fee(
+                None,
+                Some(drive_operations),
+                epoch,
+                self.config.epochs_per_era,
+                platform_version,
+                None,
+            )?
+            .processing_fee
+        } else {
+            0
+        };
+        Ok(QueryChainedDocumentsOutcomeV0 { result, cost })
+    }
+
+    #[inline(always)]
+    pub(super) fn query_chained_documents_with_proof_v0(
+        &self,
+        query: &DriveChainedDocumentQuery,
+        platform_version: &PlatformVersion,
+    ) -> Result<(Vec<u8>, Vec<dpp::document::Document>), Error> {
+        let mut drive_operations: Vec<LowLevelDriveOperation> = vec![];
+        query.execute_with_proof_internal(self, &mut drive_operations, platform_version)
+    }
+}