neo_solidity/cli/cli_parts/cli_run/
standard_json.rs

1fn try_run_standard_json(matches: &clap::ArgMatches) -> bool {
2    let use_standard_json = matches.get_flag("standard-json");
3    if !use_standard_json {
4        return false;
5    }
6
7    use std::io::{self, IsTerminal, Read};
8
9    let input_path = matches
10        .get_one::<String>("standard-json-input")
11        .map(|value| value.as_str());
12    let output_path = matches.get_one::<String>("output").map(|s| s.as_str());
13    let optimizer_level = matches
14        .get_one::<String>("optimize")
15        .and_then(|s| s.parse::<u8>().ok())
16        .unwrap_or(2)
17        .min(3);
18    let use_callt = matches.get_flag("callt");
19    let deny_wildcard_permissions = matches.get_flag("deny-wildcard-permissions");
20    let deny_wildcard_contracts = matches.get_flag("deny-wildcard-contracts");
21    let deny_wildcard_methods = matches.get_flag("deny-wildcard-methods");
22    let nef_source = matches.get_one::<String>("nef-source").map(|s| s.as_str());
23    let manifest_permissions_file = matches.get_one::<String>("manifest-permissions").map(|s| s.as_str());
24    let manifest_permissions_mode = matches
25        .get_one::<String>("manifest-permissions-mode")
26        .map(|s| s.as_str())
27        .unwrap_or("merge");
28    let contract_names: Vec<String> = matches
29        .get_many::<String>("contract")
30        .map(|vals| vals.map(|s| s.to_string()).collect())
31        .unwrap_or_default();
32
33    let manifest_permissions = match manifest_permissions_file {
34        Some(path) => match load_manifest_permissions_override(path, manifest_permissions_mode) {
35            Ok(override_permissions) => Some(override_permissions),
36            Err(err) => {
37                eprintln!("error: {err}");
38                std::process::exit(1);
39            }
40        },
41        None => None,
42    };
43
44    let result = if let Some(path) = input_path {
45        process_standard_json(
46            path,
47            output_path,
48            StandardJsonOptions {
49                optimizer_level,
50                use_callt,
51                deny_wildcard_permissions,
52                deny_wildcard_contracts,
53                deny_wildcard_methods,
54                nef_source,
55                manifest_permissions,
56                contract_names,
57            },
58        )
59    } else {
60        if io::stdin().is_terminal() {
61            eprintln!("error: --standard-json requires --input <FILE> or JSON on stdin");
62            std::process::exit(1);
63        }
64
65        let mut content = String::new();
66        if let Err(err) = io::stdin().read_to_string(&mut content) {
67            eprintln!("error: Failed to read standard JSON input from stdin: {err}");
68            std::process::exit(1);
69        }
70
71        process_standard_json_content(
72            &content,
73            output_path,
74            StandardJsonOptions {
75                optimizer_level,
76                use_callt,
77                deny_wildcard_permissions,
78                deny_wildcard_contracts,
79                deny_wildcard_methods,
80                nef_source,
81                manifest_permissions,
82                contract_names,
83            },
84        )
85    };
86
87    if let Err(err) = result {
88        eprintln!("{err}");
89        std::process::exit(1);
90    }
91
92    true
93}