neo-decompiler 0.10.1

Neo N3 NEF decompiler: parse, disassemble, lift bytecode to high-level pseudocode and C# skeletons, with a CLI, JSON reports, and optional WebAssembly bindings.
Documentation 
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

use std::io::Write as _;
use std::path::Path;

use crate::error::Result;
use crate::nef::NefParser;
use crate::util;

use super::super::args::{Cli, TokensFormat};
use super::super::reports::{self, TokensReport};

impl Cli {
    pub(super) fn run_tokens(&self, path: &Path, format: TokensFormat) -> Result<()> {
        let data = Self::read_nef_bytes(path)?;
        let parse_output = NefParser::new().parse_with_warnings(&data)?;
        let nef = parse_output.nef;
        let parse_warnings = parse_output
            .warnings
            .iter()
            .map(ToString::to_string)
            .collect::<Vec<_>>();
        let script_hash = nef.script_hash();
        let script_hash_le = util::format_hash(&script_hash);
        let script_hash_be = util::format_hash_be(&script_hash);

        if nef.method_tokens.is_empty() {
            match format {
                TokensFormat::Text => {
                    self.write_stdout(|out| {
                        writeln!(out, "(no method tokens)")?;
                        Self::write_warnings(out, &parse_warnings)
                    })?;
                }
                TokensFormat::Json => {
                    let report = TokensReport {
                        file: path.display().to_string(),
                        script_hash_le,
                        script_hash_be,
                        method_tokens: Vec::new(),
                        warnings: parse_warnings,
                    };
                    self.print_json(&report)?;
                }
            }
            return Ok(());
        }

        match format {
            TokensFormat::Text => {
                let tokens = nef
                    .method_tokens
                    .iter()
                    .map(reports::build_method_token_report)
                    .collect::<Vec<_>>();
                let mut warnings = parse_warnings;
                for warning in reports::collect_warnings(&tokens) {
                    if !warnings.contains(&warning) {
                        warnings.push(warning);
                    }
                }
                self.write_stdout(|out| {
                    for (index, token) in nef.method_tokens.iter().enumerate() {
                        writeln!(out, "{}", reports::format_method_token_line(index, token))?;
                    }
                    Self::write_warnings(out, &warnings)
                })?;
            }
            TokensFormat::Json => {
                let tokens = nef
                    .method_tokens
                    .iter()
                    .map(reports::build_method_token_report)
                    .collect::<Vec<_>>();
                let mut warnings = parse_warnings;
                for warning in reports::collect_warnings(&tokens) {
                    if !warnings.contains(&warning) {
                        warnings.push(warning);
                    }
                }
                let report = TokensReport {
                    file: path.display().to_string(),
                    script_hash_le,
                    script_hash_be,
                    warnings,
                    method_tokens: tokens,
                };
                self.print_json(&report)?;
            }
        }

        Ok(())
    }
}