neo-decompiler 0.11.0

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

use serde::Serialize;

use crate::instruction::OpCode;
use crate::native_contracts;
use crate::syscalls;
use crate::util;

#[derive(Serialize)]
pub(super) struct CatalogReport<T> {
    pub(super) kind: &'static str,
    pub(super) count: usize,
    pub(super) entries: Vec<T>,
}

#[derive(Serialize)]
pub(super) struct SyscallCatalogEntry {
    pub(super) name: String,
    pub(super) hash: String,
    pub(super) handler: String,
    pub(super) price: String,
    pub(super) call_flags: String,
    pub(super) returns_value: bool,
}

#[derive(Serialize)]
pub(super) struct NativeContractCatalogEntry {
    pub(super) name: String,
    pub(super) script_hash_le: String,
    pub(super) script_hash_be: String,
    pub(super) methods: Vec<String>,
}

#[derive(Serialize)]
pub(super) struct OpcodeCatalogEntry {
    pub(super) mnemonic: String,
    pub(super) byte: String,
    pub(super) operand_encoding: String,
}

pub(super) fn build_syscall_catalog_entries() -> Vec<SyscallCatalogEntry> {
    syscalls::all()
        .iter()
        .map(|info| SyscallCatalogEntry {
            name: info.name.to_string(),
            hash: format!("0x{:08X}", info.hash),
            handler: info.handler.to_string(),
            price: info.price.to_string(),
            call_flags: info.call_flags.to_string(),
            returns_value: info.returns_value,
        })
        .collect()
}

pub(super) fn build_native_contract_catalog_entries() -> Vec<NativeContractCatalogEntry> {
    native_contracts::all()
        .iter()
        .map(|info| NativeContractCatalogEntry {
            name: info.name.to_string(),
            script_hash_le: util::format_hash(&info.script_hash),
            script_hash_be: util::format_hash_be(&info.script_hash),
            methods: info
                .methods
                .iter()
                .map(|method| (*method).to_string())
                .collect(),
        })
        .collect()
}

pub(super) fn build_opcode_catalog_entries() -> Vec<OpcodeCatalogEntry> {
    let mut opcodes = OpCode::all_known();
    opcodes.sort_by_key(|opcode| opcode.byte());
    opcodes
        .into_iter()
        .map(|opcode| OpcodeCatalogEntry {
            mnemonic: opcode.mnemonic().to_string(),
            byte: format!("0x{:02X}", opcode.byte()),
            operand_encoding: format!("{:?}", opcode.operand_encoding()),
        })
        .collect()
}