subxt-core crate (#1466)

* start migrating, broken

* first iteration of updating

* fmt and clippy

* add Composite<u32> decoding via scale value patch

* bump scale type gen versions

* fix decoding with new scale decode

* compiling with changed deps

* core utils, condig, client, metadata

* core crate compiling

* signer crate no once lock

* add core to no-std-tests, change imports

* broken commit, start pulling everything together in subxt

* port more things to subxt

* events in core crate, extrinsics sadly much more difficult

* almost all examples pass again

* dynamic values fix in examples

* fix no std issue and fmt

* remove unused dependencies

* fix lightclient impl

* runtime version refactor

* formatting and addressing nits

* more comments addressed

* update wasm example and no-std-signer tests

* other nits and error impl on signer errors

* fix feature flag

* fix runtime version refactor

* fix doc links

* fix integration tests

* fix feature flag gated client state

* fix native feature in CI

* fix lightclient utils

* make imports more lean in subxt-core

* integrate changes from subxt-core imports into subxt

* other changes in subxt simplify imports more

* fix  and docs

* doc false for cli

* fix clippy

* remove events block hash in tests

* codegen no-std support in generated code

* export alloc crate for no-std codegen

* fix doc test

* implement James comments

* remove std traits, use core traits instead

* address nits

* remove unusued dep in no-std tests

* fix Box import in no_std

* sp-crypto-hashing instead of sp-core-hashing

* bump scale-typegen, add no std codegen tests

* fix some things

* replace unmaintained derivative with derive_where to remove non-canonical warnings

* fmt

* remove unused dep

* fix deps

* update artifacts to fix type ID mismatches

* bump to latest scale-typegen

---------

Co-authored-by: James Wilson <james@jsdw.me>

subxt/src/backend/legacy/mod.rs

@@ -181,20 +181,16 @@ 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 {
-            spec_version: details.spec_version,
-            transaction_version: details.transaction_version,
-        })
+        Ok(RuntimeVersion::new(
+            details.spec_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 {
-                spec_version: v.spec_version,
-                transaction_version: v.transaction_version,
-            })
-        });
+        let sub =
+            sub.map(|r| r.map(|v| RuntimeVersion::new(v.spec_version, v.transaction_version)));
         Ok(StreamOf(Box::pin(sub)))
     }
 

subxt/src/backend/legacy/rpc_methods.rs

@@ -8,15 +8,14 @@ use crate::backend::rpc::{rpc_params, RpcClient, RpcSubscription};
 use crate::metadata::Metadata;
 use crate::{Config, Error};
 use codec::Decode;
-use derivative::Derivative;
+use derive_where::derive_where;
 use primitive_types::U256;
 use serde::{Deserialize, Serialize};
 
 /// An interface to call the legacy RPC methods. This interface is instantiated with
 /// some `T: Config` trait which determines some of the types that the RPC methods will
 /// take or hand back.
-#[derive(Derivative)]
-#[derivative(Clone(bound = ""), Debug(bound = ""))]
+#[derive_where(Clone, Debug)]
 pub struct LegacyRpcMethods<T> {
     client: RpcClient,
     _marker: std::marker::PhantomData<T>,

subxt/src/backend/mod.rs

@@ -10,6 +10,8 @@ pub mod legacy;
 pub mod rpc;
 pub mod unstable;
 
+use subxt_core::client::RuntimeVersion;
+
 use crate::error::Error;
 use crate::metadata::Metadata;
 use crate::Config;
@@ -277,26 +279,6 @@ impl<T> StreamOf<T> {
 /// A stream of [`Result<Item, Error>`].
 pub type StreamOfResults<T> = StreamOf<Result<T, Error>>;
 
-/// Runtime version information needed to submit transactions.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct RuntimeVersion {
-    /// Version of the runtime specification. A full-node will not attempt to use its native
-    /// runtime in substitute for the on-chain Wasm runtime unless all of `spec_name`,
-    /// `spec_version` and `authoring_version` are the same between Wasm and native.
-    pub spec_version: u32,
-
-    /// All existing dispatches are fully compatible when this number doesn't change. If this
-    /// number changes, then `spec_version` must change, also.
-    ///
-    /// This number must change when an existing dispatchable (module ID, dispatch ID) is changed,
-    /// either through an alteration in its user-level semantics, a parameter
-    /// added/removed/changed, a dispatchable being removed, a module being removed, or a
-    /// dispatchable/module changing its index.
-    ///
-    /// It need *not* change when a new module is added or when a dispatchable is added.
-    pub transaction_version: u32,
-}
-
 /// The status of the transaction.
 ///
 /// If the status is [`TransactionStatus::InFinalizedBlock`], [`TransactionStatus::Error`],

subxt/src/backend/unstable/mod.rs

@@ -361,7 +361,6 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for UnstableBackend<T> {
                         for finalized_block in ev.finalized_block_hashes {
                             runtimes.remove(&finalized_block.hash());
                         }
-
                         ev.finalized_block_runtime
                     }
                     FollowEvent::NewBlock(ev) => {
@@ -417,10 +416,8 @@ impl<T: Config + Send + Sync + 'static> Backend<T> for UnstableBackend<T> {
                     RuntimeEvent::Valid(ev) => ev,
                 };
 
-                std::future::ready(Some(Ok(RuntimeVersion {
-                    spec_version: runtime_details.spec.spec_version,
-                    transaction_version: runtime_details.spec.transaction_version,
-                })))
+                let runtime_version = RuntimeVersion::new(runtime_details.spec.spec_version, runtime_details.spec.transaction_version);
+                std::future::ready(Some(Ok(runtime_version)))
             });
 
         Ok(StreamOf(Box::pin(runtime_stream)))

subxt/src/backend/unstable/rpc_methods.rs

@@ -9,7 +9,7 @@
 use crate::backend::rpc::{rpc_params, RpcClient, RpcSubscription};
 use crate::config::BlockHash;
 use crate::{Config, Error};
-use derivative::Derivative;
+use derive_where::derive_where;
 use futures::{Stream, StreamExt};
 use serde::{Deserialize, Serialize};
 use std::collections::{HashMap, VecDeque};
@@ -18,8 +18,7 @@ use std::task::Poll;
 /// An interface to call the unstable RPC methods. This interface is instantiated with
 /// some `T: Config` trait which determines some of the types that the RPC methods will
 /// take or hand back.
-#[derive(Derivative)]
-#[derivative(Clone(bound = ""), Debug(bound = ""))]
+#[derive_where(Clone, Debug)]
 pub struct UnstableRpcMethods<T> {
     client: RpcClient,
     _marker: std::marker::PhantomData<T>,