Remove unwrap and format code (#62)

* Remove unwrap from metadata fetch

* Format code

examples/submit_and_watch.rs

@@ -15,8 +15,12 @@
 // along with substrate-subxt.  If not, see <http://www.gnu.org/licenses/>.
 
 use futures::future::Future;
-use substrate_subxt::{balances, system::System, DefaultNodeRuntime as Runtime};
 use sp_keyring::AccountKeyring;
+use substrate_subxt::{
+    balances,
+    system::System,
+    DefaultNodeRuntime as Runtime,
+};
 
 type AccountId = <Runtime as System>::AccountId;
 type Balance = <Runtime as balances::Balances>::Balance;
@@ -42,13 +46,17 @@ fn main() {
     let mut rt = tokio::runtime::Runtime::new().unwrap();
     match rt.block_on(fut) {
         Ok(extrinsic_success) => {
-            match extrinsic_success.find_event::<(AccountId, AccountId, Balance, Balance)>("Balances", "Transfer") {
-                Some(Ok((_from, _to, value, _fees))) =>
-                    println!("Balance transfer success: value: {:?}", value),
+            match extrinsic_success
+                .find_event::<(AccountId, AccountId, Balance, Balance)>(
+                    "Balances", "Transfer",
+                ) {
+                Some(Ok((_from, _to, value, _fees))) => {
+                    println!("Balance transfer success: value: {:?}", value)
+                }
                 Some(Err(err)) => println!("Failed to decode code hash: {}", err),
                 None => println!("Failed to find Contracts::CodeStored Event"),
             }
-        },
-        Err(err) => println!("Error: {}", err)
+        }
+        Err(err) => println!("Error: {}", err),
     }
 }

src/events.rs

@@ -140,7 +140,12 @@ impl<T: System + Balances + 'static> EventsDecoder<T> {
                             && !self.type_sizes.contains_key(&primitive)
                             && !primitive.contains("PhantomData")
                         {
-                            missing.insert(format!("{}::{}::{}", module.name(), event.name, primitive));
+                            missing.insert(format!(
+                                "{}::{}::{}",
+                                module.name(),
+                                event.name,
+                                primitive
+                            ));
                         }
                     }
                 }

src/lib.rs

@@ -72,7 +72,10 @@ pub use self::{
     runtimes::*,
 };
 use self::{
-    events::{EventsDecoder, EventsError},
+    events::{
+        EventsDecoder,
+        EventsError,
+    },
     extrinsic::{
         DefaultExtra,
         SignedExtra,
@@ -400,7 +403,12 @@ where
     T::Address: From<T::AccountId>,
 {
     /// Access the events decoder for registering custom type sizes
-    pub fn events_decoder<F: FnOnce(&mut EventsDecoder<T>) -> Result<usize, EventsError>>(self, f: F) -> Self {
+    pub fn events_decoder<
+        F: FnOnce(&mut EventsDecoder<T>) -> Result<usize, EventsError>,
+    >(
+        self,
+        f: F,
+    ) -> Self {
         let mut this = self;
         if let Ok(ref mut decoder) = this.decoder {
             if let Err(err) = f(decoder) {

src/rpc.rs

@@ -145,10 +145,14 @@ impl<T: System> Rpc<T> {
     pub fn metadata(&self) -> impl Future<Item = Metadata, Error = Error> {
         self.state
             .metadata(None)
-            .map(|bytes| Decode::decode(&mut &bytes[..]).unwrap())
             .map_err(Into::into)
-            .and_then(|meta: RuntimeMetadataPrefixed| {
-                future::result(meta.try_into().map_err(|err| format!("{:?}", err).into()))
+            .and_then(|bytes| {
+                let result = Decode::decode(&mut &bytes[..])
+                    .map_err(Into::into)
+                    .and_then(|meta: RuntimeMetadataPrefixed| {
+                        meta.try_into().map_err(|err| format!("{:?}", err).into())
+                    });
+                future::result(result)
             })
     }