stylus-debug 0.1.1

A comprehensive debug and migration toolkit for Arbitrum Stylus (Rust-based 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
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use std::process::Command;
use serde::{Deserialize, Serialize};
use serde_json::Value;

/// A migration pattern detected in Solidity source code.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct DetectedPattern {
    pub pattern_id: String,
    pub solidity_construct: String,
    pub description: String,
    pub stylus_equivalent: String,
    pub line_number: Option<usize>,
    pub matched_text: String,
}

/// Scan Solidity source code via AST and return detected migration patterns.
pub fn detect_patterns(input_path: &std::path::Path) -> Vec<DetectedPattern> {
    let mut results = Vec::new();

    // Call JS bridge to get AST.
    let mut cmd = Command::new("node");
    let output = cmd.arg("migration-cli/src/parse_solidity.js")
        .arg(input_path)
        .output();

    let output = match output {
        Ok(o) if o.status.success() => o.stdout,
        _ => return results,
    };

    let ast: Value = serde_json::from_slice(&output).unwrap_or(Value::Null);
    if ast.is_null() { return results; }

    // Traverse AST nodes
    if let Some(children) = ast["children"].as_array() {
        for child in children {
            if child["type"] == "ContractDefinition" {
                if let Some(base_contracts) = child["baseContracts"].as_array() {
                    if !base_contracts.is_empty() {
                        results.push(DetectedPattern {
                            pattern_id: "OUT_OF_SCOPE:Inheritance".into(),
                            solidity_construct: "is ContractName".into(),
                            description: "Inheritance is currently out of scope. Stylus requires flat contract structures.".into(),
                            stylus_equivalent: "// Flatten your contracts into a single struct".into(),
                            line_number: child["loc"]["start"]["line"].as_u64().map(|l| l as usize),
                            matched_text: "contract ... is ...".into(),
                        });
                    }
                }

                if let Some(sub_children) = child["subNodes"].as_array() {
                    for node in sub_children {
                        process_node(node, &mut results);
                    }
                }
            }
        }
    }

    results
}

fn process_node(node: &Value, results: &mut Vec<DetectedPattern>) {
    let node_type = node["type"].as_str().unwrap_or("");
    let line = node["loc"]["start"]["line"].as_u64().map(|l| l as usize);

    match node_type {
        "StateVariableDeclaration" => {
            if let Some(variables) = node["variables"].as_array() {
                for var in variables {
                    let type_name = var["typeName"]["type"].as_str().unwrap_or("");
                    if type_name == "Mapping" {
                        results.push(DetectedPattern {
                            pattern_id: "mapping".into(),
                            solidity_construct: var["name"].as_str().unwrap_or("var").into(),
                            description: "Mapping type. Use StorageMap in Stylus.".into(),
                            stylus_equivalent: "sol_storage! { mapping: StorageMap<Key, Value> }".into(),
                            line_number: line,
                            matched_text: "mapping(...)".into(),
                        });
                    } else {
                        results.push(DetectedPattern {
                            pattern_id: "state_variable".into(),
                            solidity_construct: var["name"].as_str().unwrap_or("var").into(),
                            description: "State variable. Use sol_storage! in Stylus.".into(),
                            stylus_equivalent: "sol_storage! { pub <name>: Storage<Type> }".into(),
                            line_number: line,
                            matched_text: format!("{} {}", var["typeName"]["name"].as_str().unwrap_or(""), var["name"].as_str().unwrap_or("")),
                        });
                    }
                }
            }
        }
        "FunctionDefinition" => {
            if let Some(modifiers) = node["modifiers"].as_array() {
                if !modifiers.is_empty() {
                    results.push(DetectedPattern {
                        pattern_id: "OUT_OF_SCOPE:Modifiers".into(),
                        solidity_construct: "custom_modifier".into(),
                        description: "Custom modifiers are out of scope. In Stylus, inline the logic.".into(),
                        stylus_equivalent: "// Inline logic".into(),
                        line_number: line,
                        matched_text: "modifier_name".into(),
                    });
                }
            }
            // Additional function logic porting ...
        }
        _ => {}
    }
}