#[derive(Deserialize, Debug, Clone)]

    pub input_path: PathBuf,

    pub fn run(&self) {

        match &self.command {

            TanssiUtilsCmd::RewardClaimGenerator(cmd) => {

                println!("\nInput path is: {:?}\n", cmd.input_path);

                let rewards =

                    extract_rewards_data_from_file(&cmd.input_path).expect("command fail");

                generate_reward_utils(rewards)

            }

        }

    }

fn hex_to_account_id32<'de, D>(deserializer: D) -> Result<AccountId32, D::Error>

where

    D: Deserializer<'de>,

{

    let hex_str: String = Deserialize::deserialize(deserializer)?;

    let hex_trimmed = hex_str.strip_prefix("0x").unwrap_or(hex_str.as_str());

    let bytes = hex::decode(hex_trimmed).map_err(serde::de::Error::custom)?;

    let mut array = [0u8; 32];

    array.copy_from_slice(&bytes);

    Ok(AccountId32::from(array))

}

fn extract_rewards_data_from_file(reward_path: &Path) -> Result<RewardClaimInput, String> {

    let reader = std::fs::File::open(reward_path).expect("Can open file");

    let reward_input = serde_json::from_reader(&reader).expect("Cant parse reward input from JSON");

    Ok(reward_input)

}

fn generate_reward_utils(reward_input: RewardClaimInput) {

    let era_index = reward_input.era;

    let mut total_points = 0;

    let individual_rewards: BTreeMap<_, _> = reward_input

        .operator_rewards

        .clone()

        .into_iter()

        .map(|data| {

            total_points += data.amount;

            (data.account, data.amount)

        })

        .collect();

    let era_rewards = pallet_external_validators_rewards::EraRewardPoints::<AccountId32> {

        total: total_points,

        individual: individual_rewards,

    };

    let mut show_general_info = true;

    reward_input.operator_rewards.iter().for_each(|reward| {

        if let Some(account_utils) = era_rewards

            .generate_era_rewards_utils::<Keccak256>(era_index, Some(reward.account.clone()))

            if show_general_info {

                println!("=== Era Rewards Utils: Overall info ===\n");

                println!("Era index       : {:?}", era_index);

                println!("Merkle Root     : {:?}", account_utils.rewards_merkle_root);

                println!("Total Points    : {}", account_utils.total_points);

                println!("Leaves:");

                for (i, leaf) in account_utils.leaves.iter().enumerate() {

                    println!("  [{}] {:?}", i, leaf);

                }

                show_general_info = false;

                println!("\n=== Merkle Proofs ===");

            }

            let merkle_proof = account_utils

                .leaf_index

                .map(|index| merkle_proof::<Keccak256, _>(account_utils.leaves.into_iter(), index));

            if let Some(proof) = merkle_proof {

                println!(

                    "\nMerkle proof for account {:?} in era {:?}: \n",

                    reward.account, era_index

                );

                println!("   - Root: {:?}", proof.root);

                println!("   - Proof: {:?}", proof.proof);

                println!("   - Number of leaves: {:?}", proof.number_of_leaves);

                println!("   - Leaf index: {:?}", proof.leaf_index);

                println!("   - Leaf: {:?}", proof.leaf);

            } else {

                println!("No proof generated for account {:?}", reward.account);

            }

        } else {

            println!("No utils generated for account {:?}", reward.account);

        };

    });

}

fn main() {

    // Parses the options

    let cmd = TanssiUtils::parse();

    cmd.run();

}