Make signing fallable and asynchronous (#119)

* Make signing fallable and asynchronous

This is needed for hardware wallets, which require human confirmation to
sign transactions.  Blocking on a human to sign transactions is not a
good idea, and the signing might fail for many reasons (device
unplugged, authorization not granted, etc).

* Reformat

* Refactor as suggested by Andrew Jones (@ascjones).

* Use future::ok

Co-authored-by: Andrew Jones <ascjones@gmail.com>

src/signer.rs

@@ -31,13 +31,21 @@ use sp_runtime::{
     },
     traits::{
         IdentifyAccount,
+        SignedExtension,
         Verify,
     },
 };
-use std::marker::PhantomData;
+use std::{
+    future::Future,
+    marker::PhantomData,
+    pin::Pin,
+};
 
 /// Extrinsic signer.
-pub trait Signer<T: System, S: Encode, E: SignedExtra<T>> {
+pub trait Signer<T: System, S: Encode, E: SignedExtra<T>>
+where
+    <<E as SignedExtra<T>>::Extra as SignedExtension>::AdditionalSigned: Send + Sync,
+{
     /// Returns the account id.
     fn account_id(&self) -> &T::AccountId;
 
@@ -45,10 +53,23 @@ pub trait Signer<T: System, S: Encode, E: SignedExtra<T>> {
     fn nonce(&self) -> Option<T::Index>;
 
     /// Takes an unsigned extrinsic and returns a signed extrinsic.
+    ///
+    /// Some signers may fail, for instance because the hardware on which the keys are located has
+    /// refused the operation.
     fn sign(
         &self,
         extrinsic: SignedPayload<Encoded, E::Extra>,
-    ) -> UncheckedExtrinsic<T::Address, Encoded, S, E::Extra>;
+    ) -> Pin<
+        Box<
+            dyn Future<
+                    Output = Result<
+                        UncheckedExtrinsic<T::Address, Encoded, S, E::Extra>,
+                        String,
+                    >,
+                > + Send
+                + Sync,
+        >,
+    >;
 }
 
 /// Extrinsic signer using a private key.
@@ -91,12 +112,13 @@ where
 
 impl<T, S, E, P> Signer<T, S, E> for PairSigner<T, S, E, P>
 where
-    T: System,
-    T::AccountId: Into<T::Address>,
-    S: Encode,
-    E: SignedExtra<T>,
-    P: Pair,
-    P::Signature: Into<S>,
+    T: System + 'static,
+    T::AccountId: Into<T::Address> + 'static,
+    S: Encode + 'static + Send + Sync,
+    E: SignedExtra<T> + 'static,
+    P: Pair + 'static,
+    P::Signature: Into<S> + 'static,
+    <<E as SignedExtra<T>>::Extra as SignedExtension>::AdditionalSigned: Send + Sync,
 {
     fn account_id(&self) -> &T::AccountId {
         &self.account_id
@@ -109,14 +131,24 @@ where
     fn sign(
         &self,
         extrinsic: SignedPayload<Encoded, E::Extra>,
-    ) -> UncheckedExtrinsic<T::Address, Encoded, S, E::Extra> {
+    ) -> Pin<
+        Box<
+            dyn Future<
+                    Output = Result<
+                        UncheckedExtrinsic<T::Address, Encoded, S, E::Extra>,
+                        String,
+                    >,
+                > + Send
+                + Sync,
+        >,
+    > {
         let signature = extrinsic.using_encoded(|payload| self.signer.sign(payload));
         let (call, extra, _) = extrinsic.deconstruct();
-        UncheckedExtrinsic::new_signed(
+        Box::pin(futures::future::ok(UncheckedExtrinsic::new_signed(
             call,
             self.account_id.clone().into(),
             signature.into(),
             extra,
-        )
+        )))
     }
 }