pezkuwi-subxt-codegen 0.44.0

// 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 pezkuwi_subxt_metadata::{CustomValueMetadata, Metadata};
use scale_typegen::{typegen::ir::ToTokensWithSettings, TypeGenerator};
use std::collections::HashSet;

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,)*])
		}
	))
}