refactor(sdk): extract retry logic from trait default methods to fix HRTB Send issue

shumkov · claude · shumkov · commit 28d088e02299 · 2026-03-18T01:36:42.000+07:00
Move the retry + closure logic from the default methods of Fetch,
FetchMany, and FetchUnproved traits into standalone async fn helpers.
This breaks the HRTB Send inference chain that prevents tokio::spawn
from proving the resulting future is Send, without changing any call
sites or removing #[async_trait].

Also remove stale #[async_trait::async_trait] from the bare
FetchMany impl for ContenderWithSerializedDocument.

Co-Authored-By: Claude Opus 4.6 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/packages/rs-sdk/src/platform/fetch.rs b/packages/rs-sdk/src/platform/fetch.rs
@@ -158,47 +158,8 @@ where
         query: Q,
         settings: Option<RequestSettings>,
     ) -> Result<(Option<Self>, ResponseMetadata, Proof), Error> {
-        let request: &<Self as Fetch>::Request = &query.query(sdk.prove())?;
-
-        let fut = |settings: RequestSettings| async move {
-            let ExecutionResponse {
-                address,
-                retries,
-                inner: response,
-            } = request
-                .clone()
-                .execute(sdk, settings)
-                .await
-                .map_err(|execution_error| execution_error.inner_into())?;
-
-            let object_type = std::any::type_name::<Self>().to_string();
-            tracing::trace!(request = ?request, response = ?response, ?address, retries, object_type, "fetched object from platform");
-
-            let (object, response_metadata, proof): (Option<Self>, ResponseMetadata, Proof) = sdk
-                .parse_proof_with_metadata_and_proof(request.clone(), response)
-                .await
-                .map_err(|e| ExecutionError {
-                    inner: e,
-                    address: Some(address.clone()),
-                    retries,
-                })?;
-
-            match object {
-                Some(item) => Ok((item.into(), response_metadata, proof)),
-                None => Ok((None, response_metadata, proof)),
-            }
-            .map(|x| ExecutionResponse {
-                inner: x,
-                address,
-                retries,
-            })
-        };
-
-        let settings = sdk
-            .dapi_client_settings
-            .override_by(settings.unwrap_or_default());
-
-        retry(sdk.address_list(), settings, fut).await.into_inner()
+        let request = query.query(sdk.prove())?;
+        fetch_with_metadata_and_proof_impl(sdk, request, settings).await
     }
 
     /// Fetch single object from Platform.
@@ -249,6 +210,67 @@ where
     }
 }
 
+/// Standalone helper for the default `Fetch::fetch_with_metadata_and_proof`.
+///
+/// Extracting the retry + closure logic into a free `async fn` breaks the
+/// HRTB Send inference chain that prevents `tokio::spawn` from proving the
+/// resulting future is Send.
+async fn fetch_with_metadata_and_proof_impl<T, R>(
+    sdk: &Sdk,
+    request: R,
+    settings: Option<RequestSettings>,
+) -> Result<(Option<T>, ResponseMetadata, Proof), Error>
+where
+    T: Sized
+        + Debug
+        + MockResponse
+        + Send
+        + FromProof<R, Request = R, Response = <R as DapiRequest>::Response>,
+    R: TransportRequest + Into<<T as FromProof<R>>::Request>,
+{
+    let request = &request;
+
+    let fut = |settings: RequestSettings| async move {
+        let ExecutionResponse {
+            address,
+            retries,
+            inner: response,
+        } = request
+            .clone()
+            .execute(sdk, settings)
+            .await
+            .map_err(|execution_error| execution_error.inner_into())?;
+
+        let object_type = std::any::type_name::<T>().to_string();
+        tracing::trace!(request = ?request, response = ?response, ?address, retries, object_type, "fetched object from platform");
+
+        let (object, response_metadata, proof): (Option<T>, ResponseMetadata, Proof) = sdk
+            .parse_proof_with_metadata_and_proof(request.clone(), response)
+            .await
+            .map_err(|e| ExecutionError {
+                inner: e,
+                address: Some(address.clone()),
+                retries,
+            })?;
+
+        match object {
+            Some(item) => Ok((item.into(), response_metadata, proof)),
+            None => Ok((None, response_metadata, proof)),
+        }
+        .map(|x| ExecutionResponse {
+            inner: x,
+            address,
+            retries,
+        })
+    };
+
+    let settings = sdk
+        .dapi_client_settings
+        .override_by(settings.unwrap_or_default());
+
+    retry(sdk.address_list(), settings, fut).await.into_inner()
+}
+
 impl Fetch for Identity {
     type Request = IdentityRequest;
 }
diff --git a/packages/rs-sdk/src/platform/fetch_many.rs b/packages/rs-sdk/src/platform/fetch_many.rs
@@ -207,51 +207,8 @@ where
         query: Q,
         settings: Option<RequestSettings>,
     ) -> Result<(O, ResponseMetadata, Proof), Error> {
-        let request = &query.query(sdk.prove())?;
-
-        let fut = |settings: RequestSettings| async move {
-            let ExecutionResponse {
-                address,
-                retries,
-                inner: response,
-            } = request
-                .clone()
-                .execute(sdk, settings)
-                .await
-                .map_err(|e| e.inner_into())?;
-
-            let object_type = std::any::type_name::<Self>().to_string();
-            tracing::trace!(
-                request = ?request,
-                response = ?response,
-                ?address,
-                retries,
-                object_type,
-                "fetched objects from platform"
-            );
-
-            sdk.parse_proof_with_metadata_and_proof::<<Self as FetchMany<K, O>>::Request, O>(
-                request.clone(),
-                response,
-            )
-            .await
-            .map_err(|e| ExecutionError {
-                inner: e,
-                address: Some(address.clone()),
-                retries,
-            })
-            .map(|(o, metadata, proof)| ExecutionResponse {
-                inner: (o.unwrap_or_default(), metadata, proof),
-                retries,
-                address: address.clone(),
-            })
-        };
-
-        let settings = sdk
-            .dapi_client_settings
-            .override_by(settings.unwrap_or_default());
-
-        retry(sdk.address_list(), settings, fut).await.into_inner()
+        let request = query.query(sdk.prove())?;
+        fetch_many_with_metadata_and_proof_impl(sdk, request, settings).await
     }
 
     /// Fetch multiple objects from Platform by their identifiers.
@@ -306,6 +263,67 @@ where
     }
 }
 
+/// Standalone helper for the default `FetchMany::fetch_many_with_metadata_and_proof`.
+///
+/// Extracting the retry + closure logic into a free `async fn` breaks the
+/// HRTB Send inference chain that prevents `tokio::spawn` from proving the
+/// resulting future is Send.
+async fn fetch_many_with_metadata_and_proof_impl<R, O>(
+    sdk: &Sdk,
+    request: R,
+    settings: Option<RequestSettings>,
+) -> Result<(O, ResponseMetadata, Proof), Error>
+where
+    R: TransportRequest + Into<<O as FromProof<R>>::Request>,
+    O: FromProof<R, Request = R, Response = <R as TransportRequest>::Response>
+        + MockResponse
+        + Send
+        + Default,
+{
+    let request = &request;
+
+    let fut = |settings: RequestSettings| async move {
+        let ExecutionResponse {
+            address,
+            retries,
+            inner: response,
+        } = request
+            .clone()
+            .execute(sdk, settings)
+            .await
+            .map_err(|e| e.inner_into())?;
+
+        let object_type = std::any::type_name::<O>().to_string();
+        tracing::trace!(
+            request = ?request,
+            response = ?response,
+            ?address,
+            retries,
+            object_type,
+            "fetched objects from platform"
+        );
+
+        sdk.parse_proof_with_metadata_and_proof::<R, O>(request.clone(), response)
+            .await
+            .map_err(|e| ExecutionError {
+                inner: e,
+                address: Some(address.clone()),
+                retries,
+            })
+            .map(|(o, metadata, proof)| ExecutionResponse {
+                inner: (o.unwrap_or_default(), metadata, proof),
+                retries,
+                address: address.clone(),
+            })
+    };
+
+    let settings = sdk
+        .dapi_client_settings
+        .override_by(settings.unwrap_or_default());
+
+    retry(sdk.address_list(), settings, fut).await.into_inner()
+}
+
 /// Fetch documents from Platform.
 ///
 /// Returns [Documents](dpp::document::Document) indexed by their [Identifier](dpp::prelude::Identifier).
@@ -462,7 +480,6 @@ impl FetchMany<Identifier, ContestedResources> for ContestedResource {
 /// ## Supported query types
 ///
 /// * [`ContestedDocumentVotePollDriveQuery`](drive::query::vote_poll_vote_state_query::ContestedDocumentVotePollDriveQuery)
-#[async_trait::async_trait]
 impl FetchMany<Identifier, Contenders> for ContenderWithSerializedDocument {
     type Request = GetContestedResourceVoteStateRequest;
 }
diff --git a/packages/rs-sdk/src/platform/fetch_unproved.rs b/packages/rs-sdk/src/platform/fetch_unproved.rs
@@ -70,46 +70,65 @@ where
             Response = <<Self as FetchUnproved>::Request as TransportRequest>::Response,
         >,
     {
-        // Default implementation
-        let request: &<Self as FetchUnproved>::Request = &query.query(false)?;
-        let closure = move |local_settings: RequestSettings| async move {
-            // Execute the request using the Sdk instance
-            let ExecutionResponse {
-                inner: response,
-                address,
-                retries,
-            } = request
-                .clone()
-                .execute(sdk, local_settings)
-                .await
-                .map_err(|e| e.inner_into())?;
+        let request = query.query(false)?;
+        fetch_unproved_with_settings_impl(sdk, request, settings).await
+    }
+}
+
+/// Standalone helper for the default `FetchUnproved::fetch_unproved_with_settings`.
+///
+/// Extracting the retry + closure logic into a free `async fn` breaks the
+/// HRTB Send inference chain that prevents `tokio::spawn` from proving the
+/// resulting future is Send.
+async fn fetch_unproved_with_settings_impl<T, R>(
+    sdk: &Sdk,
+    request: R,
+    settings: RequestSettings,
+) -> Result<(Option<T>, ResponseMetadata), Error>
+where
+    T: Sized
+        + Debug
+        + Send
+        + FromUnproved<R, Request = R, Response = <R as TransportRequest>::Response>,
+    R: TransportRequest,
+{
+    let request = &request;
 
-            // Parse the response into the appropriate type along with metadata
-            let (object, metadata): (Option<Self>, platform_proto::ResponseMetadata) =
-                Self::maybe_from_unproved_with_metadata(
-                    request.clone(),
-                    response,
-                    sdk.network,
-                    sdk.version(),
-                )
-                .map_err(|e| ExecutionError {
-                    inner: e.into(),
-                    address: Some(address.clone()),
-                    retries,
-                })?;
+    let closure = move |local_settings: RequestSettings| async move {
+        let ExecutionResponse {
+            inner: response,
+            address,
+            retries,
+        } = request
+            .clone()
+            .execute(sdk, local_settings)
+            .await
+            .map_err(|e| e.inner_into())?;
 
-            Ok(ExecutionResponse {
-                inner: (object, metadata),
-                address,
+        let (object, metadata): (Option<T>, platform_proto::ResponseMetadata) =
+            T::maybe_from_unproved_with_metadata(
+                request.clone(),
+                response,
+                sdk.network,
+                sdk.version(),
+            )
+            .map_err(|e| ExecutionError {
+                inner: e.into(),
+                address: Some(address.clone()),
                 retries,
-            })
-        };
+            })?;
 
-        let settings = sdk.dapi_client_settings.override_by(settings);
-        retry(sdk.address_list(), settings, closure)
-            .await
-            .into_inner()
-    }
+        Ok(ExecutionResponse {
+            inner: (object, metadata),
+            address,
+            retries,
+        })
+    };
+
+    let settings = sdk.dapi_client_settings.override_by(settings);
+    retry(sdk.address_list(), settings, closure)
+        .await
+        .into_inner()
 }
 
 impl FetchUnproved for drive_proof_verifier::types::CurrentQuorumsInfo {
