Add subxt-historic crate for accesing historic (non head-of-chain) blocks (#2040)

* WIP subxt-historic

* WIP subxt-historic

* WIP subxt-historic; flesh out basic foundations

* WIP filling in extrinsic decoding functionality

* iter and decode transaction extensions

* Fill in the Online/OfflineClient APIs and move more things to be part of the chain Config

* WIP storage

* clippy, fmt, finish extrinsics example

* prep for 0.0.1 release to claim crate name

* fix README link

* fmt

* WIP thinking about storage APIs

* WIP working out storage APIs

* Storage plain value fetching first pass

* WIP storage: first pass iterating over values done

* First apss finishing storage APIs

* fmt and clippy

* Create a storage example showing fetch and iteration

* Bump to frame-decode 0.9.0

* Bump subxt-historic to 0.0.3 for preview release

* Remove unused deps

* fix import

* clippy

* doc fixes

* tweak CI and fix some cargo hack findings

* Update README: subxt-historic is prerelease

historic/src/storage/storage_entry.rs

@@ -0,0 +1,48 @@
+use super::storage_info::AnyStorageInfo;
+use super::storage_key::StorageKey;
+use super::storage_value::StorageValue;
+use crate::error::{StorageKeyError, StorageValueError};
+use scale_decode::DecodeAsType;
+
+/// This represents a storage entry, which is a key-value pair in the storage.
+pub struct StorageEntry<'entry, 'atblock> {
+    key: Vec<u8>,
+    // This contains the storage information already:
+    value: StorageValue<'entry, 'atblock>,
+}
+
+impl<'entry, 'atblock> StorageEntry<'entry, 'atblock> {
+    /// Create a new storage entry.
+    pub fn new(info: &'entry AnyStorageInfo<'atblock>, key: Vec<u8>, value: Vec<u8>) -> Self {
+        Self {
+            key,
+            value: StorageValue::new(info, value),
+        }
+    }
+
+    /// Get the raw bytes for this storage entry's key.
+    pub fn key_bytes(&self) -> &[u8] {
+        &self.key
+    }
+
+    /// Get the raw bytes for this storage entry's value.
+    pub fn value_bytes(&self) -> &[u8] {
+        self.value.bytes()
+    }
+
+    /// Consume this storage entry and return the raw bytes for the key and value.
+    pub fn into_key_and_value_bytes(self) -> (Vec<u8>, Vec<u8>) {
+        (self.key, self.value.into_bytes())
+    }
+
+    /// Decode the key for this storage entry. This gives back a type from which we can
+    /// decode specific parts of the key hash (where applicable).
+    pub fn decode_key(&'_ self) -> Result<StorageKey<'_, 'atblock>, StorageKeyError> {
+        StorageKey::new(self.value.info, &self.key)
+    }
+
+    /// Decode this storage value.
+    pub fn decode_value<T: DecodeAsType>(&self) -> Result<T, StorageValueError> {
+        self.value.decode::<T>()
+    }
+}