refactor(sdk): replace #[async_trait] with explicit BoxFuture on SDK traits

Replace #[async_trait] with explicit Pin<Box<dyn Future + Send + 'a>>
returns on Fetch, FetchMany, FetchUnproved, BroadcastStateTransition,
and all 21 transition traits in the SDK.

## Problem

The Rust compiler has a known HRTB Send inference bug
(rust-lang/rust#96865) that prevents it from proving async futures are
Send when the number of generic trait implementations exceeds a
threshold. With 28 Fetch impl types (after adding shielded pool
support), any consumer using tokio::spawn with SDK operations gets:

  error: implementation of Send is not general enough

This forced consumers (e.g. dash-evo-tool) to use spawn_blocking +
block_on as a workaround, wasting threads and blocking the async
executor.

## Solution

By returning BoxFuture explicitly instead of relying on #[async_trait],
the compiler sees Box<dyn Future + Send> and stops analyzing the inner
state machine. Send is proven by construction via the boxed trait
object. This is the same boxing that #[async_trait] performed — we just
make it explicit so the compiler's inference engine is not involved.

## Impact

- ALL SDK consumers can use tokio::spawn directly
- No spawn_blocking workaround needed
- No unsafe AssertSend wrapper needed
- No performance regression (same boxing as #[async_trait])
- WASM builds unaffected (verified)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: shumkov

packages/rs-sdk/src/platform/fetch.rs

@@ -23,6 +23,8 @@ use drive_proof_verifier::FromProof;
 use rs_dapi_client::{transport::TransportRequest, DapiRequest, RequestSettings};
 use rs_dapi_client::{ExecutionError, ExecutionResponse, InnerInto, IntoInner};
 use std::fmt::Debug;
+use std::future::Future;
+use std::pin::Pin;
 
 use super::types::identity::IdentityRequest;
 use super::DocumentQuery;
@@ -52,10 +54,10 @@ use super::DocumentQuery;
 ///
 /// let identity = Identity::fetch(&sdk, query);
 /// ```
-#[async_trait::async_trait]
 pub trait Fetch
 where
     Self: Sized
+        + Send
         + Debug
         + MockResponse
         + FromProof<
@@ -91,11 +93,13 @@ where
     /// ## Error Handling
     ///
     /// Any errors encountered during the execution are returned as [Error] instances.
-    async fn fetch<Q: Query<<Self as Fetch>::Request>>(
-        sdk: &Sdk,
+    fn fetch<'a, Q: Query<<Self as Fetch>::Request> + Send + 'a>(
+        sdk: &'a Sdk,
         query: Q,
-    ) -> Result<Option<Self>, Error> {
-        Self::fetch_with_settings(sdk, query, RequestSettings::default()).await
+    ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'a>> {
+        Box::pin(async move {
+            Self::fetch_with_settings(sdk, query, RequestSettings::default()).await
+        })
     }
 
     /// Fetch single object from Platform with metadata.
@@ -119,14 +123,17 @@ where
     /// ## Error Handling
     ///
     /// Any errors encountered during the execution are returned as [Error] instances.
-    async fn fetch_with_metadata<Q: Query<<Self as Fetch>::Request>>(
-        sdk: &Sdk,
+    fn fetch_with_metadata<'a, Q: Query<<Self as Fetch>::Request> + Send + 'a>(
+        sdk: &'a Sdk,
         query: Q,
         settings: Option<RequestSettings>,
-    ) -> Result<(Option<Self>, ResponseMetadata), Error> {
-        Self::fetch_with_metadata_and_proof(sdk, query, settings)
-            .await
-            .map(|(object, metadata, _)| (object, metadata))
+    ) -> Pin<Box<dyn Future<Output = Result<(Option<Self>, ResponseMetadata), Error>> + Send + 'a>>
+    {
+        Box::pin(async move {
+            Self::fetch_with_metadata_and_proof(sdk, query, settings)
+                .await
+                .map(|(object, metadata, _)| (object, metadata))
+        })
     }
 
     /// Fetch single object from Platform with metadata and underlying proof.
@@ -153,52 +160,56 @@ where
     /// ## Error Handling
     ///
     /// Any errors encountered during the execution are returned as [Error] instances.
-    async fn fetch_with_metadata_and_proof<Q: Query<<Self as Fetch>::Request>>(
-        sdk: &Sdk,
+    fn fetch_with_metadata_and_proof<'a, Q: Query<<Self as Fetch>::Request> + Send + 'a>(
+        sdk: &'a Sdk,
         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())?;
+    ) -> Pin<
+        Box<dyn Future<Output = Result<(Option<Self>, ResponseMetadata, Proof), Error>> + Send + 'a>,
+    > {
+        Box::pin(async move {
+            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 object_type = std::any::type_name::<Self>().to_string();
-            tracing::trace!(request = ?request, response = ?response, ?address, retries, object_type, "fetched object from platform");
+            let settings = sdk
+                .dapi_client_settings
+                .override_by(settings.unwrap_or_default());
 
-            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()
+            retry(sdk.address_list(), settings, fut).await.into_inner()
+        })
     }
 
     /// Fetch single object from Platform.
@@ -222,13 +233,15 @@ where
     /// ## Error Handling
     ///
     /// Any errors encountered during the execution are returned as [Error] instances.
-    async fn fetch_with_settings<Q: Query<<Self as Fetch>::Request>>(
-        sdk: &Sdk,
+    fn fetch_with_settings<'a, Q: Query<<Self as Fetch>::Request> + Send + 'a>(
+        sdk: &'a Sdk,
         query: Q,
         settings: RequestSettings,
-    ) -> Result<Option<Self>, Error> {
-        let (object, _) = Self::fetch_with_metadata(sdk, query, Some(settings)).await?;
-        Ok(object)
+    ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'a>> {
+        Box::pin(async move {
+            let (object, _) = Self::fetch_with_metadata(sdk, query, Some(settings)).await?;
+            Ok(object)
+        })
     }
 
     /// Fetch single object from Platform by identifier.
@@ -241,11 +254,14 @@ where
     ///
     /// - `sdk`: An instance of [Sdk].
     /// - `id`: An [Identifier] of the object to be fetched.
-    async fn fetch_by_identifier(sdk: &Sdk, id: Identifier) -> Result<Option<Self>, Error>
+    fn fetch_by_identifier<'a>(
+        sdk: &'a Sdk,
+        id: Identifier,
+    ) -> Pin<Box<dyn Future<Output = Result<Option<Self>, Error>> + Send + 'a>>
     where
         Identifier: Query<<Self as Fetch>::Request>,
     {
-        Self::fetch(sdk, id).await
+        Box::pin(async move { Self::fetch(sdk, id).await })
     }
 }