feat(dpp)!: convert Signer trait to async

packages/rs-dash-platform-macros/src/lib.rs

@@ -29,22 +29,54 @@ pub fn stack_size(attr: TokenStream, item: TokenStream) -> TokenStream {
 
     let attrs = function.attrs;
     let vis = function.vis;
-    let sig = function.sig;
+    let mut sig = function.sig;
     let block = function.block;
     let fn_ident = sig.ident.clone();
 
+    // If the function is async, we strip async from the outer signature
+    // and run the body on a new tokio current-thread runtime inside the
+    // spawned thread. This keeps the externally-visible function sync so
+    // that it works with `#[test]` (and avoids needing `#[tokio::test]`).
+    let is_async = sig.asyncness.is_some();
+    if is_async {
+        sig.asyncness = None;
+    }
+
+    // TODO(issue #3535): migrate to `dash_async::block_on` — the
+    // inline `Builder::new_current_thread().block_on(...)` pattern can
+    // deadlock inside a running runtime.
+    let spawned_body = if is_async {
+        quote! {
+            builder
+                .spawn(move || {
+                    ::tokio::runtime::Builder::new_current_thread()
+                        .enable_all()
+                        .build()
+                        .expect("failed to build tokio runtime for stack_size thread")
+                        .block_on(async move #block)
+                })
+                .expect("failed to spawn stack_size thread")
+                .join()
+                .expect("stack_size thread panicked")
+        }
+    } else {
+        quote! {
+            builder
+                .spawn(move || #block)
+                .expect("failed to spawn stack_size thread")
+                .join()
+                .expect("stack_size thread panicked")
+        }
+    };
+
     TokenStream::from(quote! {
         #(#attrs)*
         #vis #sig {
             let builder = ::std::thread::Builder::new()
                 .stack_size(#stack_size_expr)
                 .name(::std::string::String::from(stringify!(#fn_ident)));
 
-            builder
-                .spawn(|| #block)
-                .expect("failed to spawn stack_size thread")
-                .join()
-                .expect("stack_size thread panicked")
+            #spawned_body
         }
     })
 }

packages/rs-dpp/src/identity/signer.rs

@@ -1,30 +1,44 @@
 use crate::address_funds::AddressWitness;
 use crate::ProtocolError;
+use async_trait::async_trait;
 use platform_value::BinaryData;
 use std::fmt::Debug;
 use std::sync::Arc;
 
-pub trait Signer<K>: Sync + Debug {
+// `#[async_trait]` is required: `Signer` is used dyn — stored as
+// `Arc<dyn Signer<_>>` in `VTableSigner` (rs-sdk-ffi/src/signer.rs).
+#[async_trait]
+pub trait Signer<K>: Send + Sync + Debug {
     /// the public key bytes are only used to look up the private key
-    fn sign(&self, key: &K, data: &[u8]) -> Result<BinaryData, ProtocolError>;
+    async fn sign(&self, key: &K, data: &[u8]) -> Result<BinaryData, ProtocolError>;
 
     /// the public key bytes are only used to look up the private key
-    fn sign_create_witness(&self, key: &K, data: &[u8]) -> Result<AddressWitness, ProtocolError>;
+    async fn sign_create_witness(
+        &self,
+        key: &K,
+        data: &[u8],
+    ) -> Result<AddressWitness, ProtocolError>;
 
     /// do we have this identity public key in the signer?
     fn can_sign_with(&self, key: &K) -> bool;
 }
 
+#[async_trait]
 impl<K, S> Signer<K> for Arc<S>
 where
-    S: Signer<K> + ?Sized + Send,
+    K: Send + Sync,
+    S: Signer<K> + ?Sized + Send + Sync,
 {
-    fn sign(&self, key: &K, data: &[u8]) -> Result<BinaryData, ProtocolError> {
-        (**self).sign(key, data)
+    async fn sign(&self, key: &K, data: &[u8]) -> Result<BinaryData, ProtocolError> {
+        (**self).sign(key, data).await
     }
 
-    fn sign_create_witness(&self, key: &K, data: &[u8]) -> Result<AddressWitness, ProtocolError> {
-        (**self).sign_create_witness(key, data)
+    async fn sign_create_witness(
+        &self,
+        key: &K,
+        data: &[u8],
+    ) -> Result<AddressWitness, ProtocolError> {
+        (**self).sign_create_witness(key, data).await
     }
 
     fn can_sign_with(&self, key: &K) -> bool {

packages/rs-dpp/src/lib.rs

@@ -3,7 +3,13 @@
 #![forbid(unsafe_code)]
 //#![deny(missing_docs)]
 #![allow(dead_code)]
+// `ProtocolError` is the Err type of hundreds of fns here; boxing it
+// would add indirection to every return. Removing the allow needs a
+// crate-wide error refactor.
 #![allow(clippy::result_large_err)]
+// Covers static-dispatch async trait methods; dyn-safe traits like
+// `Signer` still use `#[async_trait]` at their own declaration.
+#![allow(async_fn_in_trait)]
 
 extern crate core;
 

packages/rs-dpp/src/shielded/builder/shield.rs

@@ -29,7 +29,7 @@ use super::{build_output_only_bundle, serialize_authorized_bundle, OrchardProver
 /// - `memo` - 36-byte structured memo for the recipient (4-byte type tag + 32-byte payload)
 /// - `platform_version` - Protocol version
 #[allow(clippy::too_many_arguments)]
-pub fn build_shield_transition<S: Signer<PlatformAddress>, P: OrchardProver>(
+pub async fn build_shield_transition<S: Signer<PlatformAddress>, P: OrchardProver>(
     recipient: &OrchardAddress,
     shield_amount: u64,
     inputs: BTreeMap<PlatformAddress, (AddressNonce, Credits)>,
@@ -61,6 +61,7 @@ pub fn build_shield_transition<S: Signer<PlatformAddress>, P: OrchardProver>(
         user_fee_increase,
         platform_version,
     )
+    .await
 }
 
 #[cfg(test)]
@@ -76,12 +77,17 @@ mod tests {
     #[derive(Debug)]
     struct DummySigner;
 
+    #[async_trait::async_trait]
     impl Signer<PlatformAddress> for DummySigner {
-        fn sign(&self, _key: &PlatformAddress, _data: &[u8]) -> Result<BinaryData, ProtocolError> {
+        async fn sign(
+            &self,
+            _key: &PlatformAddress,
+            _data: &[u8],
+        ) -> Result<BinaryData, ProtocolError> {
             Ok(BinaryData::new(vec![0u8; 65]))
         }
 
-        fn sign_create_witness(
+        async fn sign_create_witness(
             &self,
             _key: &PlatformAddress,
             _data: &[u8],
@@ -96,8 +102,8 @@ mod tests {
         }
     }
 
-    #[test]
-    fn test_build_shield_empty_fee_strategy() {
+    #[tokio::test]
+    async fn test_build_shield_empty_fee_strategy() {
         let recipient = test_orchard_address();
         let platform_version = PlatformVersion::latest();
         let result = build_shield_transition(
@@ -110,7 +116,8 @@ mod tests {
             &TestProver,
             [0u8; 36],
             platform_version,
-        );
+        )
+        .await;
 
         assert!(result.is_err());
         let err = result.unwrap_err().to_string();
@@ -121,8 +128,8 @@ mod tests {
         );
     }
 
-    #[test]
-    fn test_build_shield_transition_valid() {
+    #[tokio::test]
+    async fn test_build_shield_transition_valid() {
         let recipient = test_orchard_address();
         let platform_version = PlatformVersion::latest();
         // Create a P2PKH address as input
@@ -142,7 +149,8 @@ mod tests {
             &TestProver,
             [0u8; 36],
             platform_version,
-        );
+        )
+        .await;
 
         assert!(result.is_ok(), "expected Ok, got: {:?}", result.err());
         match result.unwrap() {
@@ -155,8 +163,8 @@ mod tests {
     // Extra coverage: error/edge paths not exercised above.
     // ------------------------------------------------------------
 
-    #[test]
-    fn test_build_shield_multiple_inputs_all_plumbed() {
+    #[tokio::test]
+    async fn test_build_shield_multiple_inputs_all_plumbed() {
         // Multiple input addresses should each produce their own witness
         // signature and flow through the downstream Shield transition.
         let recipient = test_orchard_address();
@@ -179,16 +187,17 @@ mod tests {
             &TestProver,
             [0u8; 36],
             platform_version,
-        );
+        )
+        .await;
         assert!(
             result.is_ok(),
             "multi-input shield should succeed: {:?}",
             result.err()
         );
     }
 
-    #[test]
-    fn test_build_shield_user_fee_increase_non_zero_succeeds() {
+    #[tokio::test]
+    async fn test_build_shield_user_fee_increase_non_zero_succeeds() {
         // The user_fee_increase param just flows through as metadata.
         // A non-zero value should not fail the bundle build.
         let recipient = test_orchard_address();
@@ -209,16 +218,17 @@ mod tests {
             &TestProver,
             [9u8; 36],
             platform_version,
-        );
+        )
+        .await;
         assert!(
             result.is_ok(),
             "non-zero user_fee_increase should succeed: {:?}",
             result.err()
         );
     }
 
-    #[test]
-    fn test_build_shield_memo_is_fully_plumbed() {
+    #[tokio::test]
+    async fn test_build_shield_memo_is_fully_plumbed() {
         // Any 36-byte memo should be accepted — this test is a guard
         // against accidental panics/regressions in memo handling.
         let recipient = test_orchard_address();
@@ -243,7 +253,8 @@ mod tests {
             &TestProver,
             memo,
             platform_version,
-        );
+        )
+        .await;
         assert!(
             result.is_ok(),
             "varied memo should succeed: {:?}",

packages/rs-dpp/src/state_transition/mod.rs

@@ -940,7 +940,7 @@ impl StateTransition {
     }
 
     #[cfg(feature = "state-transition-signing")]
-    pub fn sign_external<S: Signer<IdentityPublicKey>>(
+    pub async fn sign_external<S: Signer<IdentityPublicKey>>(
         &mut self,
         identity_public_key: &IdentityPublicKey,
         signer: &S,
@@ -954,10 +954,11 @@ impl StateTransition {
             get_data_contract_security_level_requirement,
             StateTransitionSigningOptions::default(),
         )
+        .await
     }
 
     #[cfg(feature = "state-transition-signing")]
-    pub fn sign_external_with_options<S: Signer<IdentityPublicKey>>(
+    pub async fn sign_external_with_options<S: Signer<IdentityPublicKey>>(
         &mut self,
         identity_public_key: &IdentityPublicKey,
         signer: &S,
@@ -1107,7 +1108,7 @@ impl StateTransition {
             }
         }
         let data = self.signable_bytes()?;
-        self.set_signature(signer.sign(identity_public_key, data.as_slice())?);
+        self.set_signature(signer.sign(identity_public_key, data.as_slice()).await?);
         self.set_signature_public_key_id(identity_public_key.id());
         Ok(())
     }

packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/methods/mod.rs

@@ -29,7 +29,7 @@ use platform_version::version::PlatformVersion;
 
 impl AddressCreditWithdrawalTransitionMethodsV0 for AddressCreditWithdrawalTransition {
     #[cfg(feature = "state-transition-signing")]
-    fn try_from_inputs_with_signer<S: Signer<PlatformAddress>>(
+    async fn try_from_inputs_with_signer<S: Signer<PlatformAddress>>(
         inputs: BTreeMap<PlatformAddress, (AddressNonce, Credits)>,
         output: Option<(PlatformAddress, Credits)>,
         fee_strategy: AddressFundsFeeStrategy,
@@ -57,7 +57,8 @@ impl AddressCreditWithdrawalTransitionMethodsV0 for AddressCreditWithdrawalTrans
                     signer,
                     user_fee_increase,
                     platform_version,
-                )?,
+                )
+                .await?,
             ),
             version => Err(ProtocolError::UnknownVersionMismatch {
                 method: "AddressCreditWithdrawalTransition::try_from_inputs_with_signer"

packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/methods/v0/mod.rs

@@ -24,7 +24,7 @@ use platform_version::version::PlatformVersion;
 pub trait AddressCreditWithdrawalTransitionMethodsV0 {
     #[cfg(feature = "state-transition-signing")]
     #[allow(clippy::too_many_arguments)]
-    fn try_from_inputs_with_signer<S: Signer<PlatformAddress>>(
+    async fn try_from_inputs_with_signer<S: Signer<PlatformAddress>>(
         inputs: BTreeMap<PlatformAddress, (AddressNonce, Credits)>,
         output: Option<(PlatformAddress, Credits)>,
         fee_strategy: AddressFundsFeeStrategy,

packages/rs-dpp/src/state_transition/state_transitions/address_funds/address_credit_withdrawal_transition/v0/v0_methods.rs

@@ -26,7 +26,7 @@ use platform_version::version::PlatformVersion;
 
 impl AddressCreditWithdrawalTransitionMethodsV0 for AddressCreditWithdrawalTransitionV0 {
     #[cfg(feature = "state-transition-signing")]
-    fn try_from_inputs_with_signer<S: Signer<PlatformAddress>>(
+    async fn try_from_inputs_with_signer<S: Signer<PlatformAddress>>(
         inputs: BTreeMap<PlatformAddress, (AddressNonce, Credits)>,
         output: Option<(PlatformAddress, Credits)>,
         fee_strategy: AddressFundsFeeStrategy,
@@ -61,10 +61,11 @@ impl AddressCreditWithdrawalTransitionMethodsV0 for AddressCreditWithdrawalTrans
 
         let signable_bytes = state_transition.signable_bytes()?;
 
-        address_credit_withdrawal_transition.input_witnesses = inputs
-            .keys()
-            .map(|address| signer.sign_create_witness(address, &signable_bytes))
-            .collect::<Result<Vec<AddressWitness>, ProtocolError>>()?;
+        let mut input_witnesses: Vec<AddressWitness> = Vec::with_capacity(inputs.len());
+        for address in inputs.keys() {
+            input_witnesses.push(signer.sign_create_witness(address, &signable_bytes).await?);
+        }
+        address_credit_withdrawal_transition.input_witnesses = input_witnesses;
 
         tracing::debug!("try_from_inputs_with_signer: Successfully created transition");
         Ok(address_credit_withdrawal_transition.into())