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

subxt/src/storage/storage_client.rs

@@ -2,12 +2,12 @@
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-use super::storage_type::Storage;
+use super::storage_client_at::StorageClientAt;
 use crate::{
     backend::BlockRef,
     client::{OfflineClientT, OnlineClientT},
     config::{Config, HashFor},
-    error::Error,
+    error::StorageError,
 };
 use derive_where::derive_where;
 use std::{future::Future, marker::PhantomData};
@@ -39,24 +39,9 @@ where
     /// if the address is valid (or if it's not possible to check since the address has no validation hash).
     /// Return an error if the address was not valid or something went wrong trying to validate it (ie
     /// the pallet or storage entry in question do not exist at all).
-    pub fn validate<Addr: Address>(&self, address: &Addr) -> Result<(), Error> {
+    pub fn validate<Addr: Address>(&self, address: &Addr) -> Result<(), StorageError> {
         subxt_core::storage::validate(address, &self.client.metadata()).map_err(Into::into)
     }
-
-    /// Convert some storage address into the raw bytes that would be submitted to the node in order
-    /// to retrieve the entries at the root of the associated address.
-    pub fn address_root_bytes<Addr: Address>(&self, address: &Addr) -> Vec<u8> {
-        subxt_core::storage::get_address_root_bytes(address)
-    }
-
-    /// Convert some storage address into the raw bytes that would be submitted to the node in order
-    /// to retrieve an entry. This fails if [`Address::append_entry_bytes`] does; in the built-in
-    /// implementation this would be if the pallet and storage entry being asked for is not available on the
-    /// node you're communicating with, or if the metadata is missing some type information (which should not
-    /// happen).
-    pub fn address_bytes<Addr: Address>(&self, address: &Addr) -> Result<Vec<u8>, Error> {
-        subxt_core::storage::get_address_bytes(address, &self.client.metadata()).map_err(Into::into)
-    }
 }
 
 impl<T, Client> StorageClient<T, Client>
@@ -65,22 +50,27 @@ where
     Client: OnlineClientT<T>,
 {
     /// Obtain storage at some block hash.
-    pub fn at(&self, block_ref: impl Into<BlockRef<HashFor<T>>>) -> Storage<T, Client> {
-        Storage::new(self.client.clone(), block_ref.into())
+    pub fn at(&self, block_ref: impl Into<BlockRef<HashFor<T>>>) -> StorageClientAt<T, Client> {
+        StorageClientAt::new(self.client.clone(), block_ref.into())
     }
 
     /// Obtain storage at the latest finalized block.
     pub fn at_latest(
         &self,
-    ) -> impl Future<Output = Result<Storage<T, Client>, Error>> + Send + 'static {
+    ) -> impl Future<Output = Result<StorageClientAt<T, Client>, StorageError>> + Send + 'static
+    {
         // Clone and pass the client in like this so that we can explicitly
         // return a Future that's Send + 'static, rather than tied to &self.
         let client = self.client.clone();
         async move {
             // get the ref for the latest finalized block and use that.
-            let block_ref = client.backend().latest_finalized_block_ref().await?;
+            let block_ref = client
+                .backend()
+                .latest_finalized_block_ref()
+                .await
+                .map_err(StorageError::CannotGetLatestFinalizedBlock)?;
 
-            Ok(Storage::new(client, block_ref))
+            Ok(StorageClientAt::new(client, block_ref))
         }
     }
 }