three_em_cli 0.2.0

A blazingly fast, secure, reliable, multi-language execution machine for Smart Contracts.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use crate::print_help::print_help;
use pico_args::Arguments;
use std::ops::Deref;

#[derive(Debug)]
pub enum Flags {
  Start {
    port: i32,
    host: String,
    node_capacity: i32,
  },
  Run {
    host: String,
    port: i32,
    protocol: String,
    tx: Option<String>,
    pretty_print: bool,
    no_print: bool,
    show_validity: bool,
    save: bool,
    benchmark: bool,
    save_path: String,
    height: Option<usize>,
    no_cache: bool,
    show_errors: bool,
  },
  DryRun {
    host: String,
    port: i32,
    protocol: String,
    pretty_print: bool,
    show_validity: bool,
    file: Option<String>,
  },
  Serve {
    server_host: String,
    server_port: u16,
  },
}

#[derive(Debug)]
pub enum ParseResult {
  Help { cmd: String },
  Known { flag: Flags },
}

fn parse_node_limit(
  arguments: &mut Arguments,
) -> Result<i32, pico_args::Error> {
  let node_limit = arguments.opt_value_from_str("--node-limit")?.unwrap_or(8);
  if node_limit < 8 {
    panic!("At least 8 nodes are needed.");
  }
  Ok(node_limit)
}

pub fn parse() -> Result<ParseResult, pico_args::Error> {
  let mut pargs = Arguments::from_env();
  let is_help = pargs.contains("--help");

  let cmd = pargs
    .subcommand()?
    .as_deref()
    .unwrap_or("Unknown")
    .to_string();

  if is_help {
    Ok(ParseResult::Help {
      cmd: String::from(cmd),
    })
  } else {
    #[allow(clippy::wildcard_in_or_patterns)]
    let flags = match cmd.deref() {
      "start" => ParseResult::Known {
        flag: Flags::Start {
          port: pargs.opt_value_from_str("--port")?.unwrap_or(8755),
          host: pargs
            .opt_value_from_str("--host")?
            .unwrap_or_else(|| String::from("127.0.0.1")),
          node_capacity: parse_node_limit(&mut pargs).unwrap(),
        },
      },
      "dry-run" => ParseResult::Known {
        flag: Flags::DryRun {
          host: pargs
            .opt_value_from_str("--host")?
            .unwrap_or_else(|| String::from("arweave.net")),
          port: pargs.opt_value_from_str("--port")?.unwrap_or(80),
          protocol: pargs
            .opt_value_from_str("--protocol")?
            .unwrap_or_else(|| String::from("https")),
          pretty_print: pargs.contains("--pretty-print"),
          show_validity: pargs.contains("--show-validity"),
          file: pargs.opt_value_from_str("--file").unwrap(),
        },
      },
      "run" => ParseResult::Known {
        flag: Flags::Run {
          host: pargs
            .opt_value_from_str("--host")?
            .unwrap_or_else(|| String::from("arweave.net")),
          port: pargs.opt_value_from_str("--port")?.unwrap_or(80),
          protocol: pargs
            .opt_value_from_str("--protocol")?
            .unwrap_or_else(|| String::from("https")),
          tx: pargs.opt_value_from_str("--contract-id").unwrap(),
          pretty_print: pargs.contains("--pretty-print"),
          no_print: pargs.contains("--no-print"),
          show_validity: pargs.contains("--show-validity"),
          save: pargs.contains("--save"),
          benchmark: pargs.contains("--benchmark"),
          save_path: pargs
            .opt_value_from_str("--save")?
            .unwrap_or_else(|| String::from("")),
          height: { pargs.opt_value_from_str("--height").unwrap() },
          no_cache: pargs.contains("--no-cache"),
          show_errors: pargs.contains("--show-errors"),
        },
      },
      "serve" => ParseResult::Known {
        flag: Flags::Serve {
          server_host: pargs
            .opt_value_from_str("--host")?
            .unwrap_or_else(|| String::from("127.0.0.1")),
          server_port: pargs.opt_value_from_str("--port")?.unwrap_or(5400),
        },
      },
      "Unknown" | _ => ParseResult::Help {
        cmd: String::from("none"),
      },
    };

    Ok(flags)
  }
}