Make subxt-core ready for publishing (#1508)

* Move Extrinsic decoding things to subxt_core and various tidy-ups

* A couple more fixes and fmt

* first pass moving tx logic to subxt_core

* cargo fmt

* fix wasm example

* clippy

* more clippy

* WIP Adding examples and such

* Move storage functionality more fully to subxt_core and nice examples for storage and txs

* Add example for events

* consistify how addresses/payloads are exposed in subxt-core and add runtime API fns

* Add runtime API core example

* fmt

* remove scale-info patch

* Add a little to the top level docs

* swap args around

* clippy

* cargo fmt and fix wasm-example

* doc fixes

* no-std-ise new subxt-core additions

* alloc, not core

* more no-std fixes

* A couple more fixes

* Add back extrinsic decode test

subxt/src/backend/legacy/mod.rs

@@ -181,16 +181,20 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for LegacyBackend<T> {
 
     async fn current_runtime_version(&self) -> Result<RuntimeVersion, Error> {
         let details = self.methods.state_get_runtime_version(None).await?;
-        Ok(RuntimeVersion::new(
-            details.spec_version,
-            details.transaction_version,
-        ))
+        Ok(RuntimeVersion {
+            spec_version: details.spec_version,
+            transaction_version: details.transaction_version,
+        })
     }
 
     async fn stream_runtime_version(&self) -> Result<StreamOfResults<RuntimeVersion>, Error> {
         let sub = self.methods.state_subscribe_runtime_version().await?;
-        let sub =
-            sub.map(|r| r.map(|v| RuntimeVersion::new(v.spec_version, v.transaction_version)));
+        let sub = sub.map(|r| {
+            r.map(|v| RuntimeVersion {
+                spec_version: v.spec_version,
+                transaction_version: v.transaction_version,
+            })
+        });
         Ok(StreamOf(Box::pin(sub)))
     }
 

subxt/src/backend/unstable/mod.rs

@@ -416,7 +416,10 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for UnstableBackend<T> {
                     RuntimeEvent::Valid(ev) => ev,
                 };
 
-                let runtime_version = RuntimeVersion::new(runtime_details.spec.spec_version, runtime_details.spec.transaction_version);
+                let runtime_version = RuntimeVersion {
+                    spec_version: runtime_details.spec.spec_version,
+                    transaction_version: runtime_details.spec.transaction_version
+                };
                 std::future::ready(Some(Ok(runtime_version)))
             });