Function process

src/dvf.rs:670–1428

(matches: ArgMatches)

}

fn process(matches: ArgMatches) -> Result<(), ValidationError> {
    let mut config = DVFConfig::from_matches(&matches)?;
    // Check which subcommand was used
    match matches.subcommand() {
        Some(("init", sub_m)) => {
            println!("Starting information gathering. This might take several minutes.");

            let env = *sub_m.get_one::<Environment>("env").unwrap();
            let project = sub_m.value_of("project").unwrap();
            let artifacts = sub_m.value_of("artifacts").unwrap();
            let (path, artifacts_path) = get_project_paths(project, artifacts);

            let mut imp_env = *sub_m.get_one::<Environment>("implementationenv").unwrap();
            let imp_project = sub_m.value_of("implementationproject");
            let imp_artifacts = sub_m.value_of("implementationartifacts").unwrap();
            let imp_path: PathBuf;
            let imp_artifacts_path: PathBuf;
            if let Some(imp_project) = imp_project {
                (imp_path, imp_artifacts_path) = get_project_paths(imp_project, imp_artifacts);
            } else {
                imp_path = path.clone();
                imp_artifacts_path = artifacts_path.clone();
                imp_env = env
            }

            let output_path = Path::new(sub_m.value_of("OUTPUT").unwrap());
            let mut dumped = parse::DumpedDVF::from_cli(sub_m)?;
            config.set_chain_id(dumped.chain_id)?;

            let registry = registry::Registry::from_config(&config)?;
            let pretty_printer = PrettyPrinter::new(&config, Some(&registry));

            // Parse optional initblock or take deployment_block_num + 1
            let (deployment_block_num, deployment_tx) =
                web3::get_deployment(&config, &dumped.address)?;
            info!("Deployment Block: {}", deployment_block_num);
            dumped.deployment_block_num = deployment_block_num;
            dumped.deployment_tx = deployment_tx;

            let init_block_num = match sub_m.value_of("initblock") {
                // This has been validated so we can unwrap here
                Some(b) => b.parse::<u64>().unwrap(),
                None => deployment_block_num + 1,
            };
            dumped.init_block_num = init_block_num;

            let mut pc = 1_u64;
            let progress_mode: ProgressMode = match sub_m.value_of("implementation").is_some() {
                true => ProgressMode::InitProxy,
                false => ProgressMode::Init,
            };

            print_progress("Getting code hash.", &mut pc, &progress_mode);
            let rpc_code_hash = web3::get_eth_codehash(&config, &dumped.address, init_block_num)?;
            dumped.codehash = rpc_code_hash;

            print_progress("Fetching on-chain bytecode.", &mut pc, &progress_mode);
            let rpc_code = web3::get_eth_code(&config, &dumped.address, init_block_num)?;