bat-cli 0.13.2

Blockchain Auditor Toolkit (BAT)
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
136
137
138
139
140
141

use serde::{Deserialize, Serialize};

/// Solidity function visibility levels.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EvmVisibility {
    External,
    Public,
    Internal,
    Private,
}

/// Solidity state mutability specifiers.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EvmMutability {
    Pure,
    View,
    Payable,
    NonPayable,
}

/// Types of Solidity contracts.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EvmContractType {
    Contract,
    Interface,
    Abstract,
    Library,
}

/// Access control patterns detected in Solidity code.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum AccessControlType {
    /// `onlyOwner` modifier (OpenZeppelin Ownable)
    OnlyOwner,
    /// Role-based (`hasRole`, `onlyRole`) — OpenZeppelin AccessControl
    RoleBased { role: String },
    /// Inline `require(msg.sender == ...)` check
    RequireMsgSender { compared_to: String },
    /// Custom modifier with access control semantics
    CustomModifier { name: String },
    /// No access control detected
    None,
}

/// Represents a Solidity parameter (function param or return).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmParam {
    pub name: String,
    pub type_name: String,
    pub storage_location: Option<String>,
}

/// Storage variable info.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct StorageVariable {
    pub name: String,
    pub type_name: String,
    pub visibility: EvmVisibility,
    pub is_constant: bool,
    pub is_immutable: bool,
    pub line: usize,
}

/// Event definition.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmEvent {
    pub name: String,
    pub params: Vec<EvmParam>,
    pub is_anonymous: bool,
    pub line: usize,
}

/// Modifier definition.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmModifierDef {
    pub name: String,
    pub params: Vec<EvmParam>,
    pub body_source: String,
    pub line: usize,
    #[serde(default)]
    pub end_line: usize,
    pub contract_name: String,
}

/// A parsed Solidity function.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmFunction {
    pub name: String,
    pub contract_name: String,
    pub visibility: EvmVisibility,
    pub mutability: EvmMutability,
    pub modifiers: Vec<String>,
    pub params: Vec<EvmParam>,
    pub returns: Vec<EvmParam>,
    pub body_source: String,
    pub line: usize,
    pub end_line: usize,
    pub is_constructor: bool,
    pub is_fallback: bool,
    pub is_receive: bool,
}

/// A parsed Solidity contract/interface/library.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmContract {
    pub name: String,
    pub contract_type: EvmContractType,
    pub base_contracts: Vec<String>,
    pub functions: Vec<EvmFunction>,
    pub modifiers: Vec<EvmModifierDef>,
    pub storage_variables: Vec<StorageVariable>,
    pub events: Vec<EvmEvent>,
    pub file_path: String,
    pub line: usize,
    /// true if the contract comes from lib/ (external dependency)
    pub external: bool,
}

/// A parsed .sol file containing one or more contracts.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmFile {
    pub path: String,
    pub imports: Vec<EvmImport>,
    pub contracts: Vec<EvmContract>,
    pub pragma: Option<String>,
}

/// An import statement.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct EvmImport {
    pub path: String,
    pub symbols: Vec<ImportSymbol>,
    pub line: usize,
}

/// A single imported symbol (named import).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct ImportSymbol {
    pub name: String,
    pub alias: Option<String>,
}