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/client/offline_client.rs

@@ -17,13 +17,20 @@ use subxt_core::client::{ClientState, RuntimeVersion};
 pub trait OfflineClientT<T: Config>: Clone + Send + Sync + 'static {
     /// Return the provided [`Metadata`].
     fn metadata(&self) -> Metadata;
+
     /// Return the provided genesis hash.
     fn genesis_hash(&self) -> T::Hash;
+
     /// Return the provided [`RuntimeVersion`].
     fn runtime_version(&self) -> RuntimeVersion;
+
     /// Return the [subxt_core::client::ClientState] (metadata, runtime version and genesis hash).
     fn client_state(&self) -> ClientState<T> {
-        ClientState::new(self.genesis_hash(), self.runtime_version(), self.metadata())
+        ClientState {
+            genesis_hash: self.genesis_hash(),
+            runtime_version: self.runtime_version(),
+            metadata: self.metadata(),
+        }
     }
 
     /// Work with transactions.
@@ -77,37 +84,30 @@ impl<T: Config> OfflineClient<T> {
         runtime_version: RuntimeVersion,
         metadata: impl Into<Metadata>,
     ) -> OfflineClient<T> {
+        let metadata = metadata.into();
+
         OfflineClient {
-            inner: Arc::new(ClientState::new(
+            inner: Arc::new(ClientState {
                 genesis_hash,
                 runtime_version,
-                metadata.into(),
-            )),
+                metadata,
+            }),
         }
     }
 
     /// Return the genesis hash.
     pub fn genesis_hash(&self) -> T::Hash {
-        self.inner.genesis_hash()
+        self.inner.genesis_hash
     }
 
     /// Return the runtime version.
     pub fn runtime_version(&self) -> RuntimeVersion {
-        self.inner.runtime_version()
+        self.inner.runtime_version
     }
 
     /// Return the [`Metadata`] used in this client.
     pub fn metadata(&self) -> Metadata {
-        self.inner.metadata()
-    }
-
-    /// Return the [subxt_core::client::ClientState] (metadata, runtime version and genesis hash).
-    pub fn client_state(&self) -> ClientState<T> {
-        ClientState::new(
-            self.inner.genesis_hash(),
-            self.inner.runtime_version(),
-            self.inner.metadata(),
-        )
+        self.inner.metadata.clone()
     }
 
     // Just a copy of the most important trait methods so that people
@@ -149,9 +149,6 @@ impl<T: Config> OfflineClientT<T> for OfflineClient<T> {
     fn metadata(&self) -> Metadata {
         self.metadata()
     }
-    fn client_state(&self) -> ClientState<T> {
-        self.client_state()
-    }
 }
 
 // For ergonomics; cloning a client is deliberately fairly cheap (via Arc),

subxt/src/client/online_client.rs

@@ -228,7 +228,7 @@ impl<T: Config> OnlineClient<T> {
     ///     let mut update_stream = updater.runtime_updates().await.unwrap();
     ///
     ///     while let Some(Ok(update)) = update_stream.next().await {
-    ///         let version = update.runtime_version().spec_version();
+    ///         let version = update.runtime_version().spec_version;
     ///
     ///         match updater.apply_update(update) {
     ///             Ok(()) => {
@@ -286,16 +286,6 @@ impl<T: Config> OnlineClient<T> {
         inner.runtime_version
     }
 
-    /// Return the [subxt_core::client::ClientState] (metadata, runtime version and genesis hash).
-    pub fn client_state(&self) -> ClientState<T> {
-        let inner = self.inner.read().expect("shouldn't be poisoned");
-        ClientState::new(
-            inner.genesis_hash,
-            inner.runtime_version,
-            inner.metadata.clone(),
-        )
-    }
-
     /// Change the [`RuntimeVersion`] used in this client.
     ///
     /// # Warning
@@ -371,9 +361,14 @@ impl<T: Config> OfflineClientT<T> for OnlineClient<T> {
     fn runtime_version(&self) -> RuntimeVersion {
         self.runtime_version()
     }
-
+    // This is provided by default, but we can optimise here and only lock once:
     fn client_state(&self) -> ClientState<T> {
-        self.client_state()
+        let inner = self.inner.read().expect("shouldn't be poisoned");
+        ClientState {
+            genesis_hash: inner.genesis_hash,
+            runtime_version: inner.runtime_version,
+            metadata: inner.metadata.clone(),
+        }
     }
 }
 
@@ -551,7 +546,7 @@ async fn wait_runtime_upgrade_in_finalized_block<T: Config>(
 
         // We are waiting for the chain to have the same spec version
         // as sent out via the runtime subscription.
-        if spec_version == runtime_version.spec_version() {
+        if spec_version == runtime_version.spec_version {
             break block_ref;
         }
     };