metaboss 0.49.0

The Metaplex NFT-standard Swiss Army Knife tool.
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
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use structopt::StructOpt;

use super::*;

#[derive(Debug, StructOpt)]
pub enum AirdropSubcommands {
    /// Airdrop SOL (experimental)
    #[structopt(name = "sol")]
    Sol {
        /// Path to the owner keypair file
        #[structopt(short, long)]
        keypair: Option<String>,

        /// Path to the mint list file
        #[structopt(short = "L", long)]
        recipient_list: Option<String>,

        /// Cache file
        #[structopt(short, long)]
        cache_file: Option<String>,

        /// Rate limit in requests per second; defaults to 10
        #[structopt(short = "R", long)]
        rate_limit: Option<u64>,

        /// Priority of the transaction: higher priority costs more.
        #[structopt(short = "P", long, default_value = "none")]
        priority: Priority,
    },
    /// Airdrop SPL tokens (experimental)
    #[structopt(name = "spl")]
    Spl {
        /// Path to the owner keypair file
        #[structopt(short, long)]
        keypair: Option<String>,

        /// Path to the mint list file
        #[structopt(short = "L", long)]
        recipient_list: Option<String>,

        /// Cache file
        #[structopt(short, long)]
        cache_file: Option<String>,

        /// Mint from the SPL token mint
        #[structopt(short, long)]
        mint: Pubkey,

        #[structopt(long)]
        mint_tokens: bool,

        /// Rate limit in requests per second; defaults to 10
        #[structopt(short = "R", long)]
        rate_limit: Option<u64>,

        /// Priority of the transaction: higher priority costs more.
        #[structopt(short = "P", long, default_value = "none")]
        priority: Priority,
    },
    /// Convert the bin cache file to json for readability
    ReadCache {
        /// Path to the cache file
        cache_file: String,

        /// Print errors to std out in addition to converting the cache file to json
        #[structopt(long)]
        errors: bool,
    },
}

pub async fn process_airdrop(client: RpcClient, commands: AirdropSubcommands) -> Result<()> {
    match commands {
        AirdropSubcommands::Sol {
            keypair,
            recipient_list,
            cache_file,
            priority,
            rate_limit,
        } => {
            airdrop_sol(AirdropSolArgs {
                client,
                keypair,
                recipient_list,
                cache_file,
                priority,
                rate_limit,
            })
            .await
        }
        AirdropSubcommands::Spl {
            keypair,
            recipient_list,
            cache_file,
            mint,
            mint_tokens,
            priority,
            rate_limit,
        } => {
            airdrop_spl(AirdropSplArgs {
                client,
                keypair,
                recipient_list,
                cache_file,
                mint,
                mint_tokens,
                priority,
                rate_limit,
            })
            .await
        }
        AirdropSubcommands::ReadCache { cache_file, errors } => {
            let path = std::path::Path::new(&cache_file);
            let file = File::open(path)?;
            let cache: Vec<JibFailedTransaction> = bincode::deserialize_from(file)?;

            let json_filename = path.with_extension("json");
            let pb = ProgressBar::new_spinner();
            pb.set_message("Writing cache file...");
            pb.enable_steady_tick(100);

            let cache_file = std::fs::File::create(json_filename)?;
            serde_json::to_writer(cache_file, &cache)?;
            pb.finish_and_clear();

            if errors {
                for tx in cache {
                    println!("{:?}", tx.error);
                }
            }
            Ok(())
        }
    }
}