Reference key storage api

codegen/src/api/mod.rs

@@ -442,7 +442,8 @@ fn generate_default_account_data_impl(
         };
 
     // this path to the storage entry depends on storage codegen.
-    let storage_entry_path = quote!(self::system::storage::Account);
+    // AccountDefaultData contains the same data as Account does, but without references.
+    let storage_entry_path = quote!(self::system::storage::AccountDefaultData);
 
     Some(quote! {
         /// The default storage entry from which to fetch an account nonce, required for
@@ -454,12 +455,12 @@ fn generate_default_account_data_impl(
             type AccountId = #account_id_ty;
             type Index = #account_nonce_ty;
 
-            fn nonce(result: &<Self::StorageEntry as ::subxt::StorageEntry>::Value) -> Self::Index {
-                result.nonce
-            }
             fn storage_entry(account_id: Self::AccountId) -> Self::StorageEntry {
                 #storage_entry_path(account_id)
             }
+            fn nonce(result: &<Self::StorageEntry as ::subxt::StorageEntry>::Value) -> Self::Index {
+                result.nonce
+            }
         }
     })
 }

codegen/src/api/storage.rs

@@ -74,12 +74,15 @@ fn generate_storage_entry_fns(
     storage_entry: &StorageEntryMetadata<PortableForm>,
 ) -> (TokenStream2, TokenStream2) {
     let entry_struct_ident = format_ident!("{}", storage_entry.name);
-    let (fields, entry_struct, constructor, key_impl) = match storage_entry.ty {
+    let is_account_wrapper = pallet.name == "System" && storage_entry.name == "Account";
+    let wrapper_struct_ident = format_ident!("{}DefaultData", storage_entry.name);
+    let (fields, entry_struct, constructor, key_impl, should_ref) = match storage_entry.ty
+    {
         StorageEntryType::Plain(_) => {
             let entry_struct = quote!( pub struct #entry_struct_ident; );
             let constructor = quote!( #entry_struct_ident );
             let key_impl = quote!(::subxt::StorageEntryKey::Plain);
-            (vec![], entry_struct, constructor, key_impl)
+            (vec![], entry_struct, constructor, key_impl, false)
         }
         StorageEntryType::Map {
             ref key,
@@ -120,7 +123,7 @@ fn generate_storage_entry_fns(
                         fields.iter().map(|(_, field_type)| field_type);
                     let field_names = fields.iter().map(|(field_name, _)| field_name);
                     let entry_struct = quote! {
-                        pub struct #entry_struct_ident( #( pub #tuple_struct_fields ),* );
+                        pub struct #entry_struct_ident <'a>( #( pub &'a #tuple_struct_fields ),* );
                     };
                     let constructor =
                         quote!( #entry_struct_ident( #( #field_names ),* ) );
@@ -135,13 +138,28 @@ fn generate_storage_entry_fns(
                             vec![ #( #keys ),* ]
                         )
                     };
-                    (fields, entry_struct, constructor, key_impl)
+                    (fields, entry_struct, constructor, key_impl, true)
                 }
                 _ => {
+                    let (lifetime_param, lifetime_ref) = (quote!(<'a>), quote!(&'a));
+
                     let ty_path = type_gen.resolve_type_path(key.id(), &[]);
                     let fields = vec![(format_ident!("_0"), ty_path.clone())];
+                    // `::system::storage::Account` was utilized as associated type `StorageEntry`
+                    // for `::subxt::AccountData` implementation of generated `DefaultAccountData`.
+                    // Due to changes in the storage API, `::system::storage::Account` cannot be
+                    // used without specifying a lifetime. To satisfy `::subxt::AccountData`
+                    // implementation, a non-reference wrapper `AccountDefaultData` is generated.
+                    let wrapper_struct = if is_account_wrapper {
+                        quote!(
+                            pub struct #wrapper_struct_ident ( pub #ty_path );
+                        )
+                    } else {
+                        quote!()
+                    };
                     let entry_struct = quote! {
-                        pub struct #entry_struct_ident( pub #ty_path );
+                        pub struct #entry_struct_ident #lifetime_param( pub #lifetime_ref #ty_path );
+                        #wrapper_struct
                     };
                     let constructor = quote!( #entry_struct_ident(_0) );
                     let hasher = hashers.get(0).unwrap_or_else(|| {
@@ -152,7 +170,7 @@ fn generate_storage_entry_fns(
                             vec![ ::subxt::StorageMapKey::new(&self.0, #hasher) ]
                         )
                     };
-                    (fields, entry_struct, constructor, key_impl)
+                    (fields, entry_struct, constructor, key_impl, true)
                 }
             }
         }
@@ -178,25 +196,47 @@ fn generate_storage_entry_fns(
         }
     };
 
+    let (lifetime_param, reference, anon_lifetime) = if should_ref {
+        (quote!(<'a>), quote!(&), quote!(<'_>))
+    } else {
+        (quote!(), quote!(), quote!())
+    };
+
+    let storage_entry_impl = quote! (
+        const PALLET: &'static str = #pallet_name;
+        const STORAGE: &'static str = #storage_name;
+        type Value = #storage_entry_value_ty;
+        fn key(&self) -> ::subxt::StorageEntryKey {
+            #key_impl
+        }
+    );
+
+    let wrapper_entry_impl = if is_account_wrapper {
+        quote!(
+            impl ::subxt::StorageEntry for #wrapper_struct_ident {
+                #storage_entry_impl
+            }
+        )
+    } else {
+        quote!()
+    };
+
     let storage_entry_type = quote! {
         #entry_struct
 
-        impl ::subxt::StorageEntry for #entry_struct_ident {
-            const PALLET: &'static str = #pallet_name;
-            const STORAGE: &'static str = #storage_name;
-            type Value = #storage_entry_value_ty;
-            fn key(&self) -> ::subxt::StorageEntryKey {
-                #key_impl
-            }
+        impl ::subxt::StorageEntry for #entry_struct_ident #anon_lifetime {
+            #storage_entry_impl
         }
+
+        #wrapper_entry_impl
     };
 
     let client_iter_fn = if matches!(storage_entry.ty, StorageEntryType::Map { .. }) {
         quote! (
             pub async fn #fn_name_iter(
                 &self,
                 hash: ::core::option::Option<T::Hash>,
-            ) -> ::core::result::Result<::subxt::KeyIter<'a, T, #entry_struct_ident>, ::subxt::BasicError> {
+            ) -> ::core::result::Result<::subxt::KeyIter<'a, T, #entry_struct_ident #lifetime_param>, ::subxt::BasicError> {
                 self.client.storage().iter(hash).await
             }
         )
@@ -206,7 +246,7 @@ fn generate_storage_entry_fns(
 
     let key_args = fields
         .iter()
-        .map(|(field_name, field_type)| quote!( #field_name: #field_type ));
+        .map(|(field_name, field_type)| quote!( #field_name: #reference #field_type ));
     let client_fns = quote! {
         pub async fn #fn_name(
             &self,