Function parse_bpf_command

cli/src/parser.rs:40–93

Command parsers

(matches: &ArgMatches)

// Command parsers
fn parse_bpf_command(matches: &ArgMatches) -> Result<CliCommand, CliError> {
    let mut program_infos = Vec::<ProgramInfo>::new();
    let mut clone_addresses = Vec::<Pubkey>::new();

    if let Some(values) = matches.values_of("bpf_program") {
        let values: Vec<&str> = values.collect::<Vec<_>>();
        for address_program in values.chunks(2) {
            match address_program {
                [address, program] => {
                    let address = address
                        .parse::<Pubkey>()
                        .or_else(|_| read_keypair_file(address).map(|keypair| keypair.pubkey()));

                    if address.is_err() {
                        return Err(CliError::InvalidAddress);
                    }

                    let program_path = PathBuf::from(program);

                    if !program_path.exists() {
                        return Err(CliError::InvalidProgramFile);
                    }

                    program_infos.push(ProgramInfo {
                        program_id: address.unwrap(),
                        program_path,
                    });
                }
                _ => unreachable!(),
            }
        }
    }

    if let Some(values) = matches.values_of("clone") {
        let values: Vec<&str> = values.collect::<Vec<_>>();
        for value in values {
            let address = value
                .parse::<Pubkey>()
                .map_err(|_| CliError::InvalidAddress)
                .unwrap();
            clone_addresses.push(address);
        }
    }

    Ok(CliCommand::Localnet {
        clone_addresses,
        network_url: parse_string("url", matches).ok(),
        program_infos,
        force_init: matches.is_present("force_init"),
        solana_archive: parse_string("solana_archive", matches).ok(),
        clockwork_archive: parse_string("clockwork_archive", matches).ok(),
        dev: matches.is_present("dev"),
    })
}

fn parse_config_command(matches: &ArgMatches) -> Result<CliCommand, CliError> {
    match matches.subcommand() {