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

use deno_core::error::AnyError;
use std::io::Write;
use three_em_arweave::arweave::Arweave;
use three_em_arweave::cache::ArweaveCache;
use three_em_arweave::cache::CacheExt;
use three_em_executor::execute_contract;
use three_em_executor::executor::ExecuteResult;

#[allow(clippy::too_many_arguments)]
pub async fn run(
  port: i32,
  host: String,
  protocol: String,
  tx: 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,
) -> Result<(), AnyError> {
  let arweave = Arweave::new(port, host, protocol, ArweaveCache::new());
  let start = std::time::Instant::now();

  let execution =
    execute_contract(&arweave, tx, None, None, height, !no_cache, show_errors)
      .await?;

  if benchmark {
    let elapsed = start.elapsed();
    println!("Took {}ms to execute contract", elapsed.as_millis());
  }

  match execution {
    ExecuteResult::V8(value, validity_table) => {
      let value = if show_validity {
        serde_json::json!({
            "state": value,
            "validity": validity_table
        })
      } else {
        value
      };

      if !no_print {
        if pretty_print {
          println!("{}", serde_json::to_string_pretty(&value).unwrap());
        } else {
          println!("{}", value);
        }
      }

      if save {
        let mut file = std::fs::File::create(save_path).unwrap();
        file
          .write_all(serde_json::to_vec(&value).unwrap().as_slice())
          .unwrap();
      }
    }
    ExecuteResult::Evm(store, result, validity_table) => {
      let store = hex::encode(store.raw());
      let result = hex::encode(result);

      let value = if show_validity {
        serde_json::json!({
          "result": result,
          "store": store,
          "validity": validity_table
        })
      } else {
        serde_json::json!({
          "result": result,
          "store": store,
        })
      };

      if !no_print {
        if pretty_print {
          println!("{}", serde_json::to_string_pretty(&value).unwrap());
        } else {
          println!("{}", value);
        }
      }
    }
  }

  Ok(())
}