tentacles 0.1.1

Client for the tentacles program
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

use anchor_lang::prelude::*;
use anchor_lang::solana_program::pubkey::PUBKEY_BYTES;
use anchor_lang::solana_program::program_memory::sol_memcmp;
use anchor_spl::associated_token::get_associated_token_address;
use crate::error::TentaClesError;
use crate::MemberInfo;

pub fn cmp_pubkeys(a: &Pubkey, b: &Pubkey) -> bool {
    sol_memcmp(a.as_ref(), b.as_ref(), PUBKEY_BYTES) == 0
}

pub fn assert_ata(
    account: &AccountInfo,
    target: &Pubkey,
    mint: &Pubkey,
    err: Option<TentaClesError>,
) -> Result<()> {
    let ata = get_associated_token_address(target, mint);
    if !cmp_pubkeys(&ata, account.key) {
        match err {
            Some(e) => Err(e.into()),
            None => Err(TentaClesError::InvalidArgument.into()),
        }
    } else {
        Ok(())
    }
}

pub fn assert_ata_for_pubkey(
    member_token_account: &Pubkey,
    member: &Pubkey,
    mint: &Pubkey,
    err: Option<TentaClesError>,
) -> Result<()> {
    let ata = get_associated_token_address(member, mint);
    if !cmp_pubkeys(&ata, member_token_account) {
        match err {
            Some(e) => Err(e.into()),
            None => Err(TentaClesError::InvalidArgument.into()),
        }
    } else {
        Ok(())
    }
}


pub fn assert_ata_for_keys(
    wallet_token_account: &Pubkey,
    wallet: &Pubkey,
    mint: &Pubkey,
    err: Option<TentaClesError>,
) -> Result<()> {
    let ata = get_associated_token_address(wallet, mint);
    if !cmp_pubkeys(&ata, wallet_token_account) {
        match err {
            Some(e) => Err(e.into()),
            None => Err(TentaClesError::InvalidArgument.into()),
        }
    } else {
        Ok(())
    }
}

// pub fn assert_derivation(
//     program_id: &Pubkey,
//     account: &AccountInfo,
//     path: &[&[u8]],
//     error: Option<TentaClesError>,
// ) -> Result<u8> {
//     let (key, bump) = Pubkey::find_program_address(&path, program_id);
//     if !cmp_pubkeys(&key, account.key) {
//         if error.is_some() {
//             let err = error.unwrap();
//             msg!("Derivation {:?}", err);
//             return Err(err.into());
//         }
//         msg!("DerivedKeyInvalid");
//         return Err(TentaClesError::DerivedKeyInvalid.into());
//     }
//     Ok(bump)
// }

pub fn assert_members_length(members: &Vec<MemberInfo>, max_length: usize, err: Option<TentaClesError>) -> Result<()> {
    if members.len() == max_length {
        match err {
            Some(e) => Err(e.into()),
            None => Err(error!(TentaClesError::MaxMembersReached)),
        }
    } else {
        Ok(())
    }
}

pub fn assert_available_shares(total_available_shares: u64, shares: u64, err: Option<TentaClesError>) -> Result<()> {
    if shares > total_available_shares {
        match err {
            Some(e) => Err(e.into()),
            None => Err(error!(TentaClesError::NotEnoughAvailableShares)),
        }
    } else {
        Ok(())
    }
}