shuka 0.1.0

CLI tool for fetching verified smart contract source code from blockchain explorers
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

use std::path::PathBuf;

use crate::{
    app::run_fetch,
    error::ShukaError,
    types::{ExplorerKind, FetchRequest},
};
use clap::{Args, Parser, Subcommand, ValueEnum};

#[derive(Debug, Parser)]
#[command(name = "shuka")]
pub struct Cli {
    #[arg(long, global = true)]
    pub with_banner: bool,

    #[command(subcommand)]
    pub command: Commands,
}

#[derive(Debug, Subcommand)]
pub enum Commands {
    #[command(override_usage = "shuka fetch <EXPLORER> <ADDRESS> [OPTIONS]")]
    Fetch(FetchArgs),
}

#[derive(Debug, Args)]
pub struct FetchArgs {
    pub explorer: CliExplorer,
    pub address: String,
    #[arg(long)]
    pub chain_id: Option<u32>,
    #[arg(short, long)]
    pub out: Option<PathBuf>,
}

impl FetchArgs {
    pub fn into_request(self) -> FetchRequest {
        let request: FetchRequest = FetchRequest {
            explorer: self.explorer.into(),
            address: self.address,
            chain_id: self.chain_id,
            output_dir: self.out,
        };

        request
    }
}

#[derive(Debug, Clone, ValueEnum)]
pub enum CliExplorer {
    Battlechain,
    Ethereum,
}

impl From<CliExplorer> for ExplorerKind {
    fn from(value: CliExplorer) -> Self {
        match value {
            CliExplorer::Battlechain => ExplorerKind::Battlechain,
            CliExplorer::Ethereum => ExplorerKind::Ethereum,
        }
    }
}

fn print_banner() {
    println!(
        r#"
       .__           __            
  _____|  |__  __ __|  | _______   
 /  ___/  |  \|  |  \  |/ /\__  \  
 \___ \|   Y  \  |  /    <  / __ \_
/____  >___|  /____/|__|_ \(____  /
     \/     \/           \/     \/ 
                                     
        "#
    );
}

pub fn run() -> Result<(), ShukaError> {
    let cli = Cli::parse();

    if cli.with_banner {
        print_banner();
    }

    match cli.command {
        Commands::Fetch(args) => {
            let request = args.into_request();
            let outcome = run_fetch(request)?;

            println!("Fetched source successfully");
            println!("Output directory: {}", outcome.output_path.display());
            println!("Files written: {}", outcome.files_written);

            Ok(())
        }
    }
}