construstor 0.2.1

A tool for analyzing Solidity smart contracts to detect zero address validation patterns
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
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

//! Types and data structures used throughout the application

use std::error::Error;
use std::fmt;

use serde::{Deserialize, Serialize};

/// Custom error type for the application
#[derive(Debug)]
pub enum ConstructorAnalyzerError {
    /// IO error occurred while reading files
    IoError(std::io::Error),
    /// Invalid regex pattern
    RegexError(regex::Error),
    /// File or directory not found
    NotFound(String),
    /// Invalid file format
    InvalidFormat(String),
}

impl fmt::Display for ConstructorAnalyzerError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            ConstructorAnalyzerError::IoError(err) => write!(f, "IO error: {err}"),
            ConstructorAnalyzerError::RegexError(err) => write!(f, "Regex error: {err}"),
            ConstructorAnalyzerError::NotFound(path) => write!(f, "Path not found: {path}"),
            ConstructorAnalyzerError::InvalidFormat(msg) => write!(f, "Invalid format: {msg}"),
        }
    }
}

impl Error for ConstructorAnalyzerError {}

impl From<std::io::Error> for ConstructorAnalyzerError {
    fn from(err: std::io::Error) -> Self {
        ConstructorAnalyzerError::IoError(err)
    }
}

impl From<regex::Error> for ConstructorAnalyzerError {
    fn from(err: regex::Error) -> Self {
        ConstructorAnalyzerError::RegexError(err)
    }
}

/// Represents the result of analyzing a function
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisResult {
    /// Function type (Constructor or Initialize)
    pub function_type: FunctionType,
    /// File name where the function was found
    pub file_name: String,
    /// Function arguments
    pub arguments: String,
    /// Function body code
    pub code: String,
    /// Address arguments found in the function signature
    pub address_arguments: Vec<(String, String)>,
    /// Variables that have zero address validation
    pub validated_variables: Vec<String>,
    /// Variables that are missing zero address validation
    pub missing_validations: Vec<String>,
    /// Types of validation found
    pub validation_types: Vec<ValidationType>,
}

/// Represents the result of analyzing a function for JSON output (without code field)
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AnalysisResultJson {
    /// Function type (Constructor or Initialize)
    pub function_type: FunctionType,
    /// File name where the function was found
    pub file_name: String,
    /// Function arguments
    pub arguments: String,
    /// Address arguments found in the function signature
    pub address_arguments: Vec<String>,
    /// Variables that have zero address validation
    pub validated_variables: Vec<String>,
    /// Variables that are missing zero address validation
    pub missing_validations: Vec<String>,
    /// Types of validation found
    pub validation_types: Vec<ValidationType>,
}

impl From<&AnalysisResult> for AnalysisResultJson {
    fn from(result: &AnalysisResult) -> Self {
        AnalysisResultJson {
            function_type: result.function_type.clone(),
            file_name: result.file_name.clone(),
            arguments: result.arguments.clone(),
            address_arguments: result
                .address_arguments
                .iter()
                .map(|(_, name)| name.clone())
                .collect(),
            validated_variables: result.validated_variables.clone(),
            missing_validations: result.missing_validations.clone(),
            validation_types: result.validation_types.clone(),
        }
    }
}

/// Type of function being analyzed
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum FunctionType {
    Constructor,
    Initialize,
    Regular(String), // Function name for regular functions
}

/// Type of zero address validation found
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ValidationType {
    EqualityCheck,
    RequireStatement,
}