replaced chunks with tuples in validator (#30499)

* replaced chunks with tuples in test validator

* update Cargo.lock

* replaced chunks with tuples in genesis

* Update Cargo.lock

Cargo.lock

@@ -5551,6 +5551,7 @@ dependencies = [
  "base64 0.13.0",
  "bincode",
  "clap 2.33.3",
+ "itertools",
  "serde",
  "serde_json",
  "serde_yaml 0.9.13",
@@ -6957,6 +6958,7 @@ dependencies = [
  "crossbeam-channel",
  "fd-lock",
  "indicatif",
+ "itertools",
  "jsonrpc-core",
  "jsonrpc-core-client",
  "jsonrpc-derive",

genesis/Cargo.toml

@@ -13,6 +13,7 @@ edition = { workspace = true }
 base64 = { workspace = true }
 bincode = { workspace = true }
 clap = { workspace = true }
+itertools = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 serde_yaml = { workspace = true }

genesis/src/main.rs

@@ -3,6 +3,7 @@
 
 use {
     clap::{crate_description, crate_name, value_t, value_t_or_exit, App, Arg, ArgMatches},
+    itertools::Itertools,
     solana_clap_utils::{
         input_parsers::{
             cluster_type_of, pubkey_of, pubkeys_of, unix_timestamp_from_rfc3339_datetime,
@@ -615,10 +616,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
     };
 
     if let Some(values) = matches.values_of("bpf_program") {
-        let values: Vec<&str> = values.collect::<Vec<_>>();
+        for (address, loader, program) in values.tuples() {
-        for address_loader_program in values.chunks(3) {
-            match address_loader_program {
-                [address, loader, program] => {
             let address = parse_address(address, "address");
             let loader = parse_address(loader, "loader");
             let program_data = parse_program_data(program);
@@ -633,25 +631,23 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                 }),
             );
         }
-                _ => unreachable!(),
-            }
-        }
     }
 
     if let Some(values) = matches.values_of("upgradeable_program") {
-        let values: Vec<&str> = values.collect::<Vec<_>>();
+        for (address, loader, program, upgrade_authority) in values.tuples() {
-        for address_loader_program_upgrade_authority in values.chunks(4) {
-            match address_loader_program_upgrade_authority {
-                [address, loader, program, upgrade_authority] => {
             let address = parse_address(address, "address");
             let loader = parse_address(loader, "loader");
             let program_data_elf = parse_program_data(program);
-                    let upgrade_authority_address = if *upgrade_authority == "none" {
+            let upgrade_authority_address = if upgrade_authority == "none" {
                 Pubkey::default()
             } else {
                 upgrade_authority.parse::<Pubkey>().unwrap_or_else(|_| {
-                          read_keypair_file(upgrade_authority).map(|keypair| keypair.pubkey()).unwrap_or_else(|err| {
+                    read_keypair_file(upgrade_authority)
-                              eprintln!("Error: invalid upgrade_authority {upgrade_authority}: {err}");
+                        .map(|keypair| keypair.pubkey())
+                        .unwrap_or_else(|err| {
+                            eprintln!(
+                                "Error: invalid upgrade_authority {upgrade_authority}: {err}"
+                            );
                             process::exit(1);
                         })
                 })
@@ -659,8 +655,7 @@ fn main() -> Result<(), Box<dyn error::Error>> {
 
             let (programdata_address, _) =
                 Pubkey::find_program_address(&[address.as_ref()], &loader);
-                    let mut program_data =
+            let mut program_data = bincode::serialize(&UpgradeableLoaderState::ProgramData {
-                        bincode::serialize(&UpgradeableLoaderState::ProgramData {
                 slot: 0,
                 upgrade_authority_address: Some(upgrade_authority_address),
             })
@@ -692,9 +687,6 @@ fn main() -> Result<(), Box<dyn error::Error>> {
                 }),
             );
         }
-                _ => unreachable!(),
-            }
-        }
     }
 
     solana_logger::setup();

programs/sbf/Cargo.lock

@@ -6162,6 +6162,7 @@ dependencies = [
  "crossbeam-channel",
  "fd-lock",
  "indicatif",
+ "itertools",
  "jsonrpc-core",
  "jsonrpc-core-client",
  "jsonrpc-derive",

validator/Cargo.toml

@@ -18,6 +18,7 @@ core_affinity = { workspace = true }
 crossbeam-channel = { workspace = true }
 fd-lock = { workspace = true }
 indicatif = { workspace = true }
+itertools = { workspace = true }
 jsonrpc-core = { workspace = true }
 jsonrpc-core-client = { workspace = true, features = ["ipc"] }
 jsonrpc-derive = { workspace = true }

validator/src/bin/solana-test-validator.rs

@@ -1,6 +1,7 @@
 use {
     clap::{crate_name, value_t, value_t_or_exit, values_t_or_exit},
     crossbeam_channel::unbounded,
+    itertools::Itertools,
     log::*,
     solana_clap_utils::{
         input_parsers::{pubkey_of, pubkeys_of, value_of},
@@ -203,10 +204,7 @@ fn main() {
 
     let mut upgradeable_programs_to_load = vec![];
     if let Some(values) = matches.values_of("bpf_program") {
-        let values: Vec<&str> = values.collect::<Vec<_>>();
+        for (address, program) in values.into_iter().tuples() {
-        for address_program in values.chunks(2) {
-            match address_program {
-                [address, program] => {
             let address = parse_address(address, "address");
             let program_path = parse_program_path(program);
 
@@ -217,19 +215,15 @@ fn main() {
                 program_path,
             });
         }
-                _ => unreachable!(),
-            }
-        }
     }
 
     if let Some(values) = matches.values_of("upgradeable_program") {
-        let values: Vec<&str> = values.collect::<Vec<_>>();
+        for (address, program, upgrade_authority) in
-        for address_program_upgrade_authority in values.chunks(3) {
+            values.into_iter().tuples::<(&str, &str, &str)>()
-            match address_program_upgrade_authority {
+        {
-                [address, program, upgrade_authority] => {
             let address = parse_address(address, "address");
             let program_path = parse_program_path(program);
-                    let upgrade_authority_address = if *upgrade_authority == "none" {
+            let upgrade_authority_address = if upgrade_authority == "none" {
                 Pubkey::default()
             } else {
                 upgrade_authority
@@ -238,9 +232,7 @@ fn main() {
                         read_keypair_file(upgrade_authority).map(|keypair| keypair.pubkey())
                     })
                     .unwrap_or_else(|err| {
-                                println!(
+                        println!("Error: invalid upgrade_authority {upgrade_authority}: {err}");
-                                    "Error: invalid upgrade_authority {upgrade_authority}: {err}"
-                                );
                         exit(1);
                     })
             };
@@ -252,18 +244,12 @@ fn main() {
                 program_path,
             });
         }
-                _ => unreachable!(),
-            }
-        }
     }
 
     let mut accounts_to_load = vec![];
     if let Some(values) = matches.values_of("account") {
-        let values: Vec<&str> = values.collect::<Vec<_>>();
+        for (address, filename) in values.into_iter().tuples() {
-        for address_filename in values.chunks(2) {
+            let address = if address == "-" {
-            match address_filename {
-                [address, filename] => {
-                    let address = if *address == "-" {
                 None
             } else {
                 Some(address.parse::<Pubkey>().unwrap_or_else(|err| {
@@ -274,9 +260,6 @@ fn main() {
 
             accounts_to_load.push(AccountInfo { address, filename });
         }
-                _ => unreachable!(),
-            }
-        }
     }
 
     let accounts_from_dirs: HashSet<_> = matches