Add DecodedValueThunk to allow getting bytes back from dynamic queries (#680)

subxt/src/constants/constant_address.rs

@@ -3,7 +3,7 @@
 // see LICENSE for license details.
 
 use crate::{
-    dynamic::DecodedValue,
+    dynamic::DecodedValueThunk,
     metadata::DecodeWithMetadata,
 };
 use std::borrow::Cow;
@@ -97,7 +97,7 @@ pub fn dynamic<'a>(
 }
 
 impl<'a> ConstantAddress for DynamicConstantAddress<'a> {
-    type Target = DecodedValue;
+    type Target = DecodedValueThunk;
 
     fn pallet_name(&self) -> &str {
         &self.pallet_name

subxt/src/dynamic.rs

@@ -5,6 +5,14 @@
 //! This module provides the entry points to create dynamic
 //! transactions, storage and constant lookups.
 
+use crate::{
+    error::Error,
+    metadata::{
+        DecodeWithMetadata,
+        Metadata,
+    },
+};
+
 pub use scale_value::Value;
 
 /// A [`scale_value::Value`] type endowed with contextual information
@@ -24,3 +32,50 @@ pub use crate::storage::{
     dynamic as storage,
     dynamic_root as storage_root,
 };
+
+/// This is the result of making a dynamic request to a node. From this,
+/// we can return the raw SCALE bytes that we were handed back, or we can
+/// complete the decoding of the bytes into a [`DecodedValue`] type.
+pub struct DecodedValueThunk {
+    type_id: u32,
+    metadata: Metadata,
+    scale_bytes: Vec<u8>,
+}
+
+impl DecodeWithMetadata for DecodedValueThunk {
+    type Target = Self;
+
+    fn decode_with_metadata(
+        bytes: &mut &[u8],
+        type_id: u32,
+        metadata: &Metadata,
+    ) -> Result<Self::Target, Error> {
+        let mut v = Vec::with_capacity(bytes.len());
+        v.extend_from_slice(*bytes);
+        *bytes = &[];
+        Ok(DecodedValueThunk {
+            type_id,
+            metadata: metadata.clone(),
+            scale_bytes: v,
+        })
+    }
+}
+
+impl DecodedValueThunk {
+    /// Return the SCALE encoded bytes handed back from the node.
+    pub fn to_encoded(self) -> Vec<u8> {
+        self.scale_bytes
+    }
+    /// Return the SCALE encoded bytes handed back from the node without taking ownership of them.
+    pub fn encoded(&self) -> &[u8] {
+        &self.scale_bytes
+    }
+    /// Decode the SCALE encoded storage entry into a dynamic [`DecodedValue`] type.
+    pub fn to_value(&self) -> Result<DecodedValue, Error> {
+        DecodedValue::decode_with_metadata(
+            &mut &*self.scale_bytes,
+            self.type_id,
+            &self.metadata,
+        )
+    }
+}

subxt/src/storage/storage_address.rs

@@ -5,7 +5,7 @@
 use super::storage_map_key::StorageMapKey;
 use crate::{
     dynamic::{
-        DecodedValue,
+        DecodedValueThunk,
         Value,
     },
     error::{
@@ -194,7 +194,7 @@ impl<'a, Encodable> StorageAddress for DynamicStorageAddress<'a, Encodable>
 where
     Encodable: EncodeWithMetadata,
 {
-    type Target = DecodedValue;
+    type Target = DecodedValueThunk;
 
     // For dynamic types, we have no static guarantees about any of
     // this stuff, so we just allow it and let it fail at runtime: