Merge v0.50.x to master (#2127)

* v0.50.0: Integrate frame-decode, redo storage APIs and break up Error. (#2100)

* WIP integrating new frame-decode and working out new storage APIS

* WIP: first pass adding new storage things to subxt-core

* Second pass over Address type and start impl in Subxt

* WIP new storage APIs

* WIP New storage APIs roughly completed, lots of errors still

* Remove PlainorMap enum; plain and map values now use same struct to simplify usage

* Begin 'fixing' errors

* WIP splitting errors and tidying payload/address traits

* Get subxt-core compiling

* Small fixes in subxt-core and remove metadata mod

* subxt-core: cargo check --all-targets passes

* Fix test

* WIP starting to update subxt from subxt-core changes

* WIP splitting up subxt errors into smaller variants

* WIP errors: add DispatchError errors

* Port new Storage APIs to subxt-core

* cargo check -p subxt passes

* Quick-fix errors in subxt-cli (explore subcommand)

* fmt

* Finish fixing codegen up and start fixing examples

* get Subxt examples compiling and bytes_at for constants

* Add some arcs to limit lifetimes in subxt/subxt-core storage APIs

* A little Arcing to allow more method chaining in Storage APIs, aligning with Subxt

* Update codegen test

* cargo check --all-targets passing

* cargo check --features 'unstable-light-client' passing

* clippy

* Remove unused dep in subxt

* use published frame-decode

* fix wasm-example

* Add new tx extension to fix daily tests

* Remove unused subxt_core::dynamic::DecodedValue type

* Update book to match changes

* Update docs to fix more broken bits

* Add missing docs

* fmt

* allow larger result errs for now

* Add missing alloc imports in subxt-core

* Fix doc tests and fix bug getting constant info

* Fix V14 -> Metadata transform for storage & constants

* Fix parachain example

* Fix FFI example

* BlockLength decodes t ostruct, not u128

* use fetch/iter shorthands rather than entry in most storage tests

* Fix some integration tests

* Fix Runtime codegen tests

* Expose the dynamic custom_value selecter and use in a UI test

* Update codegen metadata

* Tidy CLI storage query and support (str,str) as a storage address

* Add (str,str) as valid constant address too

* Show string tuple in constants example

* Via the magic of traits, avoid needing any clones of queries/addresses and accept references to them

* clippy

* [v0.50] update scale-info-legacy and frame-decode to latest (#2119)

* bump scale-info-legacy and frame-decode to latest

* Remove something we don't need in this PR

* Fully remove unused for now dep

* [v0.50] Convert historic metadata to subxt::Metadata (#2120)

* First pass converting historic metadatas to our subxt::Metadata type

* use published frame-decode

* fmt and rename legacy metadata macro

* Enable legacy feature where needed in subxt_metadata so it compiles on its own

* Use cargo hack more in CI and fix subxt-metadata features

* Add tests for metadata conversion (need to optimise; some too expensive right now

* Address performance and equality issues in metadata conversion testing

* fmt

* fmt all

* clippy

* Fix a doc link

* Test codegen and fixes to make it work

* Remove local frame-decode patch

* bump frame-decode to latest

* [v0.50.0] Allow visiting extrinsic fields in subxt_historic (#2124)

* Allow visiting extrinsic fields

* fmt

* Don't use local scale-decode dep

* Clippy and tidy

* Extend 'subxt codegen' CLI to work with legacy metadatas

* Simplify historic extrinsics example now that AccountId32s have paths/names

* clippy

* clippy

* clippy..

* Allow visiting storage values, too, and clean up extrinsic visiting a little by narrowing lifetime

* Try to fix flaky test

* Add custom value decode to extrinsics example

* Remove useless else branch ra thought I needed

* Simplify examples

* Prep to release v0.0.5 (#2126)

subxt/src/custom_values/custom_values_client.rs

@@ -1,8 +1,8 @@
 use crate::client::OfflineClientT;
-use crate::{Config, Error};
+use crate::{Config, error::CustomValueError};
 use derive_where::derive_where;
 
-use subxt_core::custom_values::address::{Address, Yes};
+use subxt_core::custom_values::address::{Address, Maybe};
 
 /// A client for accessing custom values stored in the metadata.
 #[derive_where(Clone; Client)]
@@ -24,29 +24,29 @@ impl<T, Client> CustomValuesClient<T, Client> {
 impl<T: Config, Client: OfflineClientT<T>> CustomValuesClient<T, Client> {
     /// Access a custom value by the address it is registered under. This can be just a [str] to get back a dynamic value,
     /// or a static address from the generated static interface to get a value of a static type returned.
-    pub fn at<Addr: Address<IsDecodable = Yes> + ?Sized>(
+    pub fn at<Addr: Address<IsDecodable = Maybe>>(
         &self,
-        address: &Addr,
-    ) -> Result<Addr::Target, Error> {
-        subxt_core::custom_values::get(address, &self.client.metadata()).map_err(Into::into)
+        address: Addr,
+    ) -> Result<Addr::Target, CustomValueError> {
+        subxt_core::custom_values::get(address, &self.client.metadata())
     }
 
     /// Access the bytes of a custom value by the address it is registered under.
-    pub fn bytes_at<Addr: Address + ?Sized>(&self, address: &Addr) -> Result<Vec<u8>, Error> {
-        subxt_core::custom_values::get_bytes(address, &self.client.metadata()).map_err(Into::into)
+    pub fn bytes_at<Addr: Address>(&self, address: Addr) -> Result<Vec<u8>, CustomValueError> {
+        subxt_core::custom_values::get_bytes(address, &self.client.metadata())
     }
 
     /// Run the validation logic against some custom value address you'd like to access. Returns `Ok(())`
     /// if the address is valid (or if it's not possible to check since the address has no validation hash).
     /// Returns an error if the address was not valid (wrong name, type or raw bytes)
-    pub fn validate<Addr: Address + ?Sized>(&self, address: &Addr) -> Result<(), Error> {
-        subxt_core::custom_values::validate(address, &self.client.metadata()).map_err(Into::into)
+    pub fn validate<Addr: Address>(&self, address: Addr) -> Result<(), CustomValueError> {
+        subxt_core::custom_values::validate(address, &self.client.metadata())
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::custom_values::CustomValuesClient;
+    use crate::custom_values::{self, CustomValuesClient};
     use crate::{Metadata, OfflineClient, SubstrateConfig};
     use codec::Encode;
     use scale_decode::DecodeAsType;
@@ -104,7 +104,7 @@ mod tests {
         };
 
         let metadata: subxt_metadata::Metadata = frame_metadata.try_into().unwrap();
-        Metadata::from(metadata)
+        metadata
     }
 
     #[test]
@@ -117,10 +117,12 @@ mod tests {
             },
             mock_metadata(),
         );
+
         let custom_value_client = CustomValuesClient::new(client);
         assert!(custom_value_client.at("No one").is_err());
-        let person_decoded_value_thunk = custom_value_client.at("Person").unwrap();
-        let person: Person = person_decoded_value_thunk.as_type().unwrap();
+
+        let person_addr = custom_values::dynamic::<Person>("Person");
+        let person = custom_value_client.at(&person_addr).unwrap();
         assert_eq!(
             person,
             Person {