starkli 0.1.2

Starkli (/ˈstɑːrklaɪ/), a blazing fast CLI tool for Starknet powered by starknet-rs
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

use std::{io::Write, path::PathBuf};

use anyhow::Result;
use clap::Parser;
use colored::Colorize;
use starknet::{
    core::types::{BlockId, BlockTag, FieldElement, FunctionCall},
    macros::selector,
    providers::Provider,
};

use crate::{
    account::{
        AccountConfig, AccountVariant, AccountVariantType, DeployedStatus, DeploymentStatus,
        OzAccountConfig, KNOWN_ACCOUNT_CLASSES,
    },
    ProviderArgs,
};

#[derive(Debug, Parser)]
pub struct Fetch {
    #[clap(flatten)]
    provider: ProviderArgs,
    #[clap(long, help = "Overwrite the file if it already exists")]
    force: bool,
    #[clap(long, help = "Path to save the account config file")]
    output: Option<PathBuf>,
    #[clap(help = "Contract address")]
    address: String,
}

impl Fetch {
    pub async fn run(self) -> Result<()> {
        // We allow not saving the config to just identify the account contract
        if self.output.is_none() {
            eprintln!(
                "{}",
                "NOTE: --output is not supplied and the account config won't be persisted."
                    .bright_magenta()
            );
        }

        if self.output.as_ref().is_some_and(|output| output.exists()) && !self.force {
            anyhow::bail!("account config file already exists");
        }

        let provider = self.provider.into_provider();
        let address = FieldElement::from_hex_be(&self.address)?;

        let class_hash = provider
            .get_class_hash_at(BlockId::Tag(BlockTag::Pending), address)
            .await?;

        let known_class = match KNOWN_ACCOUNT_CLASSES
            .iter()
            .find(|class| class.class_hash == class_hash)
        {
            Some(class) => class,
            None => {
                eprintln!(
                    "{} is not a known account class hash. \
                    If you believe this is a bug, submit a PR to:",
                    format!("{:#064x}", class_hash).bright_yellow()
                );
                eprintln!("    https://github.com/xJonathanLEI/starkli");
                anyhow::bail!("unknown class hash: {:#064x}", class_hash);
            }
        };

        eprintln!(
            "Account contract type identified as: {}",
            format!("{}", known_class.variant).bright_yellow()
        );
        eprintln!("Description: {}", known_class.description.bright_yellow());

        // No need to proceed if the user doesn't even want to save the config
        let output = match self.output {
            Some(output) => output,
            None => return Ok(()),
        };

        let account = match known_class.variant {
            AccountVariantType::OpenZeppelin => {
                let public_key = provider
                    .call(
                        FunctionCall {
                            contract_address: address,
                            entry_point_selector: selector!("getPublicKey"),
                            calldata: vec![],
                        },
                        BlockId::Tag(BlockTag::Pending),
                    )
                    .await?[0];

                AccountConfig {
                    version: 1,
                    variant: AccountVariant::OpenZeppelin(OzAccountConfig {
                        version: 1,
                        public_key,
                    }),
                    deployment: DeploymentStatus::Deployed(DeployedStatus {
                        class_hash,
                        address,
                    }),
                }
            }
        };

        let mut file = std::fs::File::create(&output)?;
        serde_json::to_writer_pretty(&mut file, &account)?;
        file.write_all(b"\n")?;

        eprintln!(
            "Downloaded new account config file: {}",
            std::fs::canonicalize(&output)?.display()
        );

        Ok(())
    }
}