gramr 0.0.1

⚔️ A blazing-fast library for scaffolding smart contracts
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

use crate::error::{GramrError, Result};
use crate::foundry::FoundryProject;
use colored::*;
use std::fs;

pub struct ScriptGenerator {
    project: FoundryProject,
    script_name: String,
    pragma: String,
    license: String,
}

impl ScriptGenerator {
    pub fn new(
        project: FoundryProject,
        script_name: String,
        pragma: String,
        license: String,
    ) -> Self {
        Self {
            project,
            script_name,
            pragma,
            license,
        }
    }

    pub fn generate(&self) -> Result<()> {
        self.validate_name()?;
        self.project.ensure_directories()?;
        self.create_script_file()?;
        self.print_success();
        Ok(())
    }

    fn validate_name(&self) -> Result<()> {
        if self.script_name.is_empty() {
            return Err(GramrError::InvalidContractName(
                "Script name cannot be empty".to_string(),
            ));
        }

        if !self.script_name.chars().next().unwrap().is_alphabetic() {
            return Err(GramrError::InvalidContractName(
                "Script name must start with a letter".to_string(),
            ));
        }

        if !self
            .script_name
            .chars()
            .all(|c| c.is_alphanumeric() || c == '_')
        {
            return Err(GramrError::InvalidContractName(
                "Script name can only contain letters, numbers, and underscores".to_string(),
            ));
        }

        Ok(())
    }

    fn create_script_file(&self) -> Result<()> {
        let file_path = self
            .project
            .script_dir
            .join(format!("{}.s.sol", self.script_name));

        if file_path.exists() {
            return Err(GramrError::FileExists(file_path.display().to_string()));
        }

        let content = self.generate_script_content();
        fs::write(&file_path, content)?;

        println!("{} Created script: {}", "✓".green(), file_path.display());
        Ok(())
    }

    fn generate_script_content(&self) -> String {
        format!(
            r#"// SPDX-License-Identifier: {}
pragma solidity ^{};

import "forge-std/Script.sol";

contract {} is Script {{
    function setUp() public {{}}

    function run() public {{
        uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
        vm.startBroadcast(deployerPrivateKey);

        // Deploy contracts here

        vm.stopBroadcast();
    }}
}}"#,
            self.license, self.pragma, self.script_name
        )
    }

    fn print_success(&self) {
        println!("\n{} Script generation complete!", "🎉".green());
        println!("\n{}", "Next steps:".bold());
        println!("  1. Add your deployment logic to the run() function");
        println!("  2. Set the PRIVATE_KEY environment variable");
        println!(
            "  3. Run {} to execute",
            format!("forge script script/{}.s.sol", self.script_name).cyan()
        );
    }
}