sugar-cli 2.9.1

Command line tool for creating and managing Metaplex Candy Machines.
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
134

use std::{
    ops::Deref,
    sync::{Arc, Mutex},
};

use anchor_client::solana_sdk::pubkey::Pubkey;
use anyhow::Result;
use console::style;
use mpl_candy_guard::{
    guards::FreezeEscrow,
    state::{CandyGuardData, DATA_OFFSET},
};
use serde::{Deserialize, Serialize, Serializer};
use solana_client::{rpc_client::RpcClient, rpc_request::RpcRequest};
use solana_program::{instruction::AccountMeta, program_pack::Pack};
use spl_associated_token_account::get_associated_token_address;
use spl_token::state::Account as SplAccount;
use tokio::sync::Semaphore;

use crate::{
    cache::load_cache,
    common::*,
    config::{get_config_data, Cluster, ConfigData, SugarConfig},
    pdas::*,
    setup::get_rpc_url,
    utils::{
        get_cluster, get_cm_creator_mint_accounts, progress_bar_with_style, spinner_with_style,
    },
};

mod initialize;
mod thaw;
mod unlock_funds;

pub use initialize::*;
pub use thaw::*;
pub use unlock_funds::*;

pub fn find_freeze_pda(
    candy_guard_id: &Pubkey,
    candy_machine_id: &Pubkey,
    destination: &Pubkey,
) -> (Pubkey, u8) {
    let freeze_seeds = &[
        FreezeEscrow::PREFIX_SEED,
        destination.as_ref(),
        candy_guard_id.as_ref(),
        candy_machine_id.as_ref(),
    ];

    Pubkey::find_program_address(freeze_seeds, &mpl_candy_guard::ID)
}

pub fn get_destination<C: Deref<Target = impl Signer> + Clone>(
    program: &Program<C>,
    candy_guard: &Pubkey,
    config_data: ConfigData,
    label: &Option<String>,
) -> Result<(Pubkey, Option<Pubkey>)> {
    // first tries to get the on-chain information

    if let Ok(account_data) = program.rpc().get_account_data(candy_guard) {
        // deserialises the candy guard data
        let candy_guard_data = CandyGuardData::load(&account_data[DATA_OFFSET..])?;

        match &label {
            // if we have a label, need to find the group
            Some(label) => {
                let clone = label.to_owned();
                if let Some(groups) = &candy_guard_data.groups {
                    for group in groups {
                        if group.label == clone {
                            if let Some(guard) = &group.guards.freeze_sol_payment {
                                return Ok((guard.destination, None));
                            }
                            if let Some(guard) = candy_guard_data.default.freeze_token_payment {
                                return Ok((guard.destination_ata, Some(guard.mint)));
                            }
                        }
                    }
                }
            }
            None => {
                if let Some(guard) = candy_guard_data.default.freeze_sol_payment {
                    return Ok((guard.destination, None));
                }
                if let Some(guard) = candy_guard_data.default.freeze_token_payment {
                    return Ok((guard.destination_ata, Some(guard.mint)));
                }
            }
        }
    }

    // if on-chain was not successful, check the config data

    if let Some(guards) = config_data.guards {
        match &label {
            // if we have a label, need to find the group
            Some(label) => {
                let clone = label.to_owned();
                if let Some(groups) = &guards.groups {
                    for group in groups {
                        if group.label == clone {
                            return if let Some(guard) = &group.guards.freeze_sol_payment {
                                Ok((guard.destination, None))
                            } else if let Some(guard) = &group.guards.freeze_token_payment {
                                Ok((guard.destination_ata, Some(guard.mint)))
                            } else {
                                Err(anyhow!(
                                    "Missing freeze payment guard for group with label '{label}'"
                                ))
                            };
                        }
                    }
                    // reaching this point means that we did not find the group
                    Err(anyhow!("Could not find group with label '{label}'"))
                } else {
                    Err(anyhow!("Missig group configuration"))
                }
            }
            None => {
                if let Some(guard) = guards.default.freeze_sol_payment {
                    Ok((guard.destination, None))
                } else if let Some(guard) = guards.default.freeze_token_payment {
                    Ok((guard.destination_ata, Some(guard.mint)))
                } else {
                    Err(anyhow!("Missing freeze payment guard configuration"))
                }
            }
        }
    } else {
        Err(anyhow!("Missing guards configuration"))
    }
}