fix: Convert vendor/pezkuwi-subxt from submodule to regular directory

vendor/pezkuwi-subxt/codegen/src/api/custom_values.rs

@@ -0,0 +1,78 @@
+// Copyright 2019-2025 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+use heck::ToSnakeCase as _;
+use scale_typegen::TypeGenerator;
+use scale_typegen::typegen::ir::ToTokensWithSettings;
+use std::collections::HashSet;
+use pezkuwi_subxt_metadata::{CustomValueMetadata, Metadata};
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+/// Generate the custom values mod, if there are any custom values in the metadata. Else returns None.
+pub fn generate_custom_values(
+    metadata: &Metadata,
+    type_gen: &TypeGenerator,
+    crate_path: &syn::Path,
+) -> TokenStream2 {
+    let mut fn_names_taken = HashSet::new();
+    let custom = metadata.custom();
+    let custom_values_fns = custom.iter().filter_map(|custom_value| {
+        generate_custom_value_fn(custom_value, type_gen, crate_path, &mut fn_names_taken)
+    });
+
+    quote! {
+        pub struct CustomValuesApi;
+
+        impl CustomValuesApi {
+            #(#custom_values_fns)*
+        }
+    }
+}
+
+/// Generates runtime functions for the given API metadata.
+/// Returns None, if the name would not make for a valid identifier.
+fn generate_custom_value_fn(
+    custom_value: CustomValueMetadata,
+    type_gen: &TypeGenerator,
+    crate_path: &syn::Path,
+    fn_names_taken: &mut HashSet<String>,
+) -> Option<TokenStream2> {
+    // names are transformed to snake case to make for good function identifiers.
+    let name = custom_value.name();
+    let fn_name = name.to_snake_case();
+    if fn_names_taken.contains(&fn_name) {
+        return None;
+    }
+    // if the fn_name would be an invalid ident, return None:
+    let fn_name_ident = syn::parse_str::<syn::Ident>(&fn_name).ok()?;
+    fn_names_taken.insert(fn_name);
+
+    let custom_value_hash = custom_value.hash();
+
+    // for custom values it is important to check if the type id is actually in the metadata:
+    let type_is_valid = custom_value
+        .types()
+        .resolve(custom_value.type_id())
+        .is_some();
+
+    let (return_ty, decodable) = if type_is_valid {
+        let return_ty = type_gen
+            .resolve_type_path(custom_value.type_id())
+            .expect("type is in metadata; qed")
+            .to_token_stream(type_gen.settings());
+        let decodable = quote!(#crate_path::utils::Maybe);
+        (return_ty, decodable)
+    } else {
+        // if type registry does not contain the type, we can just return the Encoded scale bytes.
+        (quote!(()), quote!(#crate_path::utils::No))
+    };
+
+    Some(quote!(
+        pub fn #fn_name_ident(&self) -> #crate_path::custom_values::address::StaticAddress<#return_ty, #decodable> {
+            #crate_path::custom_values::address::StaticAddress::new_static(#name, [#(#custom_value_hash,)*])
+        }
+    ))
+}